daily update
[binutils.git] / bfd / syms.c
blob1f25d33815cda43c3d0315f37e68f9fa4eabefd4
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, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
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.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
25 SECTION
26 Symbols
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
59 INODE
60 Reading Symbols, Writing Symbols, Symbols, Symbols
61 SUBSECTION
62 Reading symbols
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:
68 | long storage_needed;
69 | asymbol **symbol_table;
70 | long number_of_symbols;
71 | long i;
73 | storage_needed = bfd_get_symtab_upper_bound (abfd);
75 | if (storage_needed < 0)
76 | FAIL
78 | if (storage_needed == 0)
79 | return;
81 | symbol_table = xmalloc (storage_needed);
82 | ...
83 | number_of_symbols =
84 | bfd_canonicalize_symtab (abfd, symbol_table);
86 | if (number_of_symbols < 0)
87 | FAIL
89 | for (i = 0; i < number_of_symbols; i++)
90 | process_symbol (symbol_table[i]);
92 All storage for the symbols themselves is in an objalloc
93 connected to the BFD; it is freed when the BFD is closed.
95 INODE
96 Writing Symbols, Mini Symbols, Reading Symbols, Symbols
97 SUBSECTION
98 Writing symbols
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:
110 | #include "bfd.h"
111 | int main (void)
113 | bfd *abfd;
114 | asymbol *ptrs[2];
115 | asymbol *new;
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;
125 | ptrs[0] = new;
126 | ptrs[1] = 0;
128 | bfd_set_symtab (abfd, ptrs, 1);
129 | bfd_close (abfd);
130 | return 0;
133 | ./makesym
134 | nm foo
135 | 00012345 A dummy_symbol
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.
143 INODE
144 Mini Symbols, typedef asymbol, Writing Symbols, Symbols
145 SUBSECTION
146 Mini Symbols
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.
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.
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.
168 DOCDD
169 INODE
170 typedef asymbol, symbol handling functions, Mini Symbols, Symbols
174 SUBSECTION
175 typedef asymbol
177 An <<asymbol>> has the form:
182 CODE_FRAGMENT
185 .typedef struct bfd_symbol
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.
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. *}
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;
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;
207 . {* Attributes of a symbol. *}
208 .#define BSF_NO_FLAGS 0x00
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)
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)
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. *}
222 . {* A normal C symbol would be one of:
223 . <<BSF_LOCAL>>, <<BSF_COMMON>>, <<BSF_UNDEFINED>> or
224 . <<BSF_GLOBAL>>. *}
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)
230 . {* The symbol denotes a function entry point. Used in ELF,
231 . perhaps others someday. *}
232 .#define BSF_FUNCTION (1 << 3)
234 . {* Used by the linker. *}
235 .#define BSF_KEEP (1 << 5)
236 .#define BSF_KEEP_G (1 << 6)
238 . {* A weak global symbol, overridable without warnings by
239 . a regular global symbol of the same name. *}
240 .#define BSF_WEAK (1 << 7)
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)
246 . {* The symbol used to be a common symbol, but now it is
247 . allocated. *}
248 .#define BSF_OLD_COMMON (1 << 9)
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)
257 . {* Signal that the symbol is the label of constructor section. *}
258 .#define BSF_CONSTRUCTOR (1 << 11)
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)
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)
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)
274 . {* Symbol is from dynamic linking information. *}
275 .#define BSF_DYNAMIC (1 << 15)
277 . {* The symbol denotes a data object. Used in ELF, and perhaps
278 . others someday. *}
279 .#define BSF_OBJECT (1 << 16)
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)
286 . {* This symbol is thread local. Used in ELF. *}
287 .#define BSF_THREAD_LOCAL (1 << 18)
289 . {* This symbol represents a complex relocation expression,
290 . with the expression tree serialized in the symbol name. *}
291 .#define BSF_RELC (1 << 19)
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)
297 . {* This symbol was created by bfd_get_synthetic_symtab. *}
298 .#define BSF_SYNTHETIC (1 << 21)
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 . {* This symbol is a globally unique data object. The dynamic linker
306 . will make sure that in the entire process there is just one symbol
307 . with this name and type in use. BSF_OBJECT must also be set. *}
308 .#define BSF_GNU_UNIQUE (1 << 23)
310 . flagword flags;
312 . {* A pointer to the section to which this symbol is
313 . relative. This will always be non NULL, there are special
314 . sections for undefined and absolute symbols. *}
315 . struct bfd_section *section;
317 . {* Back end special data. *}
318 . union
320 . void *p;
321 . bfd_vma i;
323 . udata;
325 .asymbol;
329 #include "sysdep.h"
330 #include "bfd.h"
331 #include "libbfd.h"
332 #include "safe-ctype.h"
333 #include "bfdlink.h"
334 #include "aout/stab_gnu.h"
337 DOCDD
338 INODE
339 symbol handling functions, , typedef asymbol, Symbols
340 SUBSECTION
341 Symbol handling functions
345 FUNCTION
346 bfd_get_symtab_upper_bound
348 DESCRIPTION
349 Return the number of bytes required to store a vector of pointers
350 to <<asymbols>> for all the symbols in the BFD @var{abfd},
351 including a terminal NULL pointer. If there are no symbols in
352 the BFD, then return 0. If an error occurs, return -1.
354 .#define bfd_get_symtab_upper_bound(abfd) \
355 . BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
360 FUNCTION
361 bfd_is_local_label
363 SYNOPSIS
364 bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
366 DESCRIPTION
367 Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
368 a compiler generated local label, else return FALSE.
371 bfd_boolean
372 bfd_is_local_label (bfd *abfd, asymbol *sym)
374 /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
375 starts with '.' is local. This would accidentally catch section names
376 if we didn't reject them here. */
377 if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0)
378 return FALSE;
379 if (sym->name == NULL)
380 return FALSE;
381 return bfd_is_local_label_name (abfd, sym->name);
385 FUNCTION
386 bfd_is_local_label_name
388 SYNOPSIS
389 bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
391 DESCRIPTION
392 Return TRUE if a symbol with the name @var{name} in the BFD
393 @var{abfd} is a compiler generated local label, else return
394 FALSE. This just checks whether the name has the form of a
395 local label.
397 .#define bfd_is_local_label_name(abfd, name) \
398 . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
403 FUNCTION
404 bfd_is_target_special_symbol
406 SYNOPSIS
407 bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
409 DESCRIPTION
410 Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something
411 special to the particular target represented by the BFD. Such symbols
412 should normally not be mentioned to the user.
414 .#define bfd_is_target_special_symbol(abfd, sym) \
415 . BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
420 FUNCTION
421 bfd_canonicalize_symtab
423 DESCRIPTION
424 Read the symbols from the BFD @var{abfd}, and fills in
425 the vector @var{location} with pointers to the symbols and
426 a trailing NULL.
427 Return the actual number of symbol pointers, not
428 including the NULL.
430 .#define bfd_canonicalize_symtab(abfd, location) \
431 . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
436 FUNCTION
437 bfd_set_symtab
439 SYNOPSIS
440 bfd_boolean bfd_set_symtab
441 (bfd *abfd, asymbol **location, unsigned int count);
443 DESCRIPTION
444 Arrange that when the output BFD @var{abfd} is closed,
445 the table @var{location} of @var{count} pointers to symbols
446 will be written.
449 bfd_boolean
450 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
452 if (abfd->format != bfd_object || bfd_read_p (abfd))
454 bfd_set_error (bfd_error_invalid_operation);
455 return FALSE;
458 bfd_get_outsymbols (abfd) = location;
459 bfd_get_symcount (abfd) = symcount;
460 return TRUE;
464 FUNCTION
465 bfd_print_symbol_vandf
467 SYNOPSIS
468 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
470 DESCRIPTION
471 Print the value and flags of the @var{symbol} supplied to the
472 stream @var{file}.
474 void
475 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
477 FILE *file = (FILE *) arg;
479 flagword type = symbol->flags;
481 if (symbol->section != NULL)
482 bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
483 else
484 bfd_fprintf_vma (abfd, file, symbol->value);
486 /* This presumes that a symbol can not be both BSF_DEBUGGING and
487 BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
488 BSF_OBJECT. */
489 fprintf (file, " %c%c%c%c%c%c%c",
490 ((type & BSF_LOCAL)
491 ? (type & BSF_GLOBAL) ? '!' : 'l'
492 : (type & BSF_GLOBAL) ? 'g'
493 : (type & BSF_GNU_UNIQUE) ? 'u' : ' '),
494 (type & BSF_WEAK) ? 'w' : ' ',
495 (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
496 (type & BSF_WARNING) ? 'W' : ' ',
497 (type & BSF_INDIRECT) ? 'I' : (type & BSF_GNU_INDIRECT_FUNCTION) ? 'i' : ' ',
498 (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
499 ((type & BSF_FUNCTION)
500 ? 'F'
501 : ((type & BSF_FILE)
502 ? 'f'
503 : ((type & BSF_OBJECT) ? 'O' : ' '))));
507 FUNCTION
508 bfd_make_empty_symbol
510 DESCRIPTION
511 Create a new <<asymbol>> structure for the BFD @var{abfd}
512 and return a pointer to it.
514 This routine is necessary because each back end has private
515 information surrounding the <<asymbol>>. Building your own
516 <<asymbol>> and pointing to it will not create the private
517 information, and will cause problems later on.
519 .#define bfd_make_empty_symbol(abfd) \
520 . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
525 FUNCTION
526 _bfd_generic_make_empty_symbol
528 SYNOPSIS
529 asymbol *_bfd_generic_make_empty_symbol (bfd *);
531 DESCRIPTION
532 Create a new <<asymbol>> structure for the BFD @var{abfd}
533 and return a pointer to it. Used by core file routines,
534 binary back-end and anywhere else where no private info
535 is needed.
538 asymbol *
539 _bfd_generic_make_empty_symbol (bfd *abfd)
541 bfd_size_type amt = sizeof (asymbol);
542 asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
543 if (new_symbol)
544 new_symbol->the_bfd = abfd;
545 return new_symbol;
549 FUNCTION
550 bfd_make_debug_symbol
552 DESCRIPTION
553 Create a new <<asymbol>> structure for the BFD @var{abfd},
554 to be used as a debugging symbol. Further details of its use have
555 yet to be worked out.
557 .#define bfd_make_debug_symbol(abfd,ptr,size) \
558 . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
562 struct section_to_type
564 const char *section;
565 char type;
568 /* Map section names to POSIX/BSD single-character symbol types.
569 This table is probably incomplete. It is sorted for convenience of
570 adding entries. Since it is so short, a linear search is used. */
571 static const struct section_to_type stt[] =
573 {".bss", 'b'},
574 {"code", 't'}, /* MRI .text */
575 {".data", 'd'},
576 {"*DEBUG*", 'N'},
577 {".debug", 'N'}, /* MSVC's .debug (non-standard debug syms) */
578 {".drectve", 'i'}, /* MSVC's .drective section */
579 {".edata", 'e'}, /* MSVC's .edata (export) section */
580 {".fini", 't'}, /* ELF fini section */
581 {".idata", 'i'}, /* MSVC's .idata (import) section */
582 {".init", 't'}, /* ELF init section */
583 {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */
584 {".rdata", 'r'}, /* Read only data. */
585 {".rodata", 'r'}, /* Read only data. */
586 {".sbss", 's'}, /* Small BSS (uninitialized data). */
587 {".scommon", 'c'}, /* Small common. */
588 {".sdata", 'g'}, /* Small initialized data. */
589 {".text", 't'},
590 {"vars", 'd'}, /* MRI .data */
591 {"zerovars", 'b'}, /* MRI .bss */
592 {0, 0}
595 /* Return the single-character symbol type corresponding to
596 section S, or '?' for an unknown COFF section.
598 Check for any leading string which matches, so .text5 returns
599 't' as well as .text */
601 static char
602 coff_section_type (const char *s)
604 const struct section_to_type *t;
606 for (t = &stt[0]; t->section; t++)
607 if (!strncmp (s, t->section, strlen (t->section)))
608 return t->type;
610 return '?';
613 /* Return the single-character symbol type corresponding to section
614 SECTION, or '?' for an unknown section. This uses section flags to
615 identify sections.
617 FIXME These types are unhandled: c, i, e, p. If we handled these also,
618 we could perhaps obsolete coff_section_type. */
620 static char
621 decode_section_type (const struct bfd_section *section)
623 if (section->flags & SEC_CODE)
624 return 't';
625 if (section->flags & SEC_DATA)
627 if (section->flags & SEC_READONLY)
628 return 'r';
629 else if (section->flags & SEC_SMALL_DATA)
630 return 'g';
631 else
632 return 'd';
634 if ((section->flags & SEC_HAS_CONTENTS) == 0)
636 if (section->flags & SEC_SMALL_DATA)
637 return 's';
638 else
639 return 'b';
641 if (section->flags & SEC_DEBUGGING)
642 return 'N';
643 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
644 return 'n';
646 return '?';
650 FUNCTION
651 bfd_decode_symclass
653 DESCRIPTION
654 Return a character corresponding to the symbol
655 class of @var{symbol}, or '?' for an unknown class.
657 SYNOPSIS
658 int bfd_decode_symclass (asymbol *symbol);
661 bfd_decode_symclass (asymbol *symbol)
663 char c;
665 if (symbol->section && bfd_is_com_section (symbol->section))
666 return 'C';
667 if (bfd_is_und_section (symbol->section))
669 if (symbol->flags & BSF_WEAK)
671 /* If weak, determine if it's specifically an object
672 or non-object weak. */
673 if (symbol->flags & BSF_OBJECT)
674 return 'v';
675 else
676 return 'w';
678 else
679 return 'U';
681 if (bfd_is_ind_section (symbol->section))
682 return 'I';
683 if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION)
684 return 'i';
685 if (symbol->flags & BSF_WEAK)
687 /* If weak, determine if it's specifically an object
688 or non-object weak. */
689 if (symbol->flags & BSF_OBJECT)
690 return 'V';
691 else
692 return 'W';
694 if (symbol->flags & BSF_GNU_UNIQUE)
695 return 'u';
696 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
697 return '?';
699 if (bfd_is_abs_section (symbol->section))
700 c = 'a';
701 else if (symbol->section)
703 c = coff_section_type (symbol->section->name);
704 if (c == '?')
705 c = decode_section_type (symbol->section);
707 else
708 return '?';
709 if (symbol->flags & BSF_GLOBAL)
710 c = TOUPPER (c);
711 return c;
713 /* We don't have to handle these cases just yet, but we will soon:
714 N_SETV: 'v';
715 N_SETA: 'l';
716 N_SETT: 'x';
717 N_SETD: 'z';
718 N_SETB: 's';
719 N_INDR: 'i';
724 FUNCTION
725 bfd_is_undefined_symclass
727 DESCRIPTION
728 Returns non-zero if the class symbol returned by
729 bfd_decode_symclass represents an undefined symbol.
730 Returns zero otherwise.
732 SYNOPSIS
733 bfd_boolean bfd_is_undefined_symclass (int symclass);
736 bfd_boolean
737 bfd_is_undefined_symclass (int symclass)
739 return symclass == 'U' || symclass == 'w' || symclass == 'v';
743 FUNCTION
744 bfd_symbol_info
746 DESCRIPTION
747 Fill in the basic info about symbol that nm needs.
748 Additional info may be added by the back-ends after
749 calling this function.
751 SYNOPSIS
752 void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
755 void
756 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
758 ret->type = bfd_decode_symclass (symbol);
760 if (bfd_is_undefined_symclass (ret->type))
761 ret->value = 0;
762 else
763 ret->value = symbol->value + symbol->section->vma;
765 ret->name = symbol->name;
769 FUNCTION
770 bfd_copy_private_symbol_data
772 SYNOPSIS
773 bfd_boolean bfd_copy_private_symbol_data
774 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
776 DESCRIPTION
777 Copy private symbol information from @var{isym} in the BFD
778 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
779 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
780 returns are:
782 o <<bfd_error_no_memory>> -
783 Not enough memory exists to create private data for @var{osec}.
785 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
786 . BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
787 . (ibfd, isymbol, obfd, osymbol))
791 /* The generic version of the function which returns mini symbols.
792 This is used when the backend does not provide a more efficient
793 version. It just uses BFD asymbol structures as mini symbols. */
795 long
796 _bfd_generic_read_minisymbols (bfd *abfd,
797 bfd_boolean dynamic,
798 void **minisymsp,
799 unsigned int *sizep)
801 long storage;
802 asymbol **syms = NULL;
803 long symcount;
805 if (dynamic)
806 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
807 else
808 storage = bfd_get_symtab_upper_bound (abfd);
809 if (storage < 0)
810 goto error_return;
811 if (storage == 0)
812 return 0;
814 syms = (asymbol **) bfd_malloc (storage);
815 if (syms == NULL)
816 goto error_return;
818 if (dynamic)
819 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
820 else
821 symcount = bfd_canonicalize_symtab (abfd, syms);
822 if (symcount < 0)
823 goto error_return;
825 *minisymsp = syms;
826 *sizep = sizeof (asymbol *);
827 return symcount;
829 error_return:
830 bfd_set_error (bfd_error_no_symbols);
831 if (syms != NULL)
832 free (syms);
833 return -1;
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. */
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)
846 return *(asymbol **) minisym;
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. */
858 /* We use a cache by default. */
860 #define ENABLE_CACHING
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. */
866 struct indexentry
868 bfd_vma val;
869 bfd_byte *stab;
870 bfd_byte *str;
871 char *directory_name;
872 char *file_name;
873 char *function_name;
876 /* Compare two indexentry structures. This is called via qsort. */
878 static int
879 cmpindexentry (const void *a, const void *b)
881 const struct indexentry *contestantA = (const struct indexentry *) a;
882 const struct indexentry *contestantB = (const struct indexentry *) b;
884 if (contestantA->val < contestantB->val)
885 return -1;
886 else if (contestantA->val > contestantB->val)
887 return 1;
888 else
889 return 0;
892 /* A pointer to this structure is stored in *pinfo. */
894 struct stab_find_info
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;
905 /* A table that indexes stabs by memory address. */
906 struct indexentry *indextable;
907 /* The number of entries in indextable. */
908 int indextablesize;
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
918 /* Saved ptr to malloc'ed filename. */
919 char *filename;
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)
933 struct stab_find_info *info;
934 bfd_size_type stabsize, strsize;
935 bfd_byte *stab, *str;
936 bfd_byte *last_stab = NULL;
937 bfd_size_type stroff;
938 struct indexentry *indexentry;
939 char *file_name;
940 char *directory_name;
941 int saw_fun;
942 bfd_boolean saw_line, saw_func;
944 *pfound = FALSE;
945 *pfilename = bfd_get_filename (abfd);
946 *pfnname = NULL;
947 *pline = 0;
949 /* Stabs entries use a 12 byte format:
950 4 byte string table index
951 1 byte stab type
952 1 byte stab other field
953 2 byte stab desc field
954 4 byte stab value
955 FIXME: This will have to change for a 64 bit object format.
957 The stabs symbols are divided into compilation units. For the
958 first entry in each unit, the type of 0, the value is the length
959 of the string table for this unit, and the desc field is the
960 number of stabs symbols for this unit. */
962 #define STRDXOFF (0)
963 #define TYPEOFF (4)
964 #define OTHEROFF (5)
965 #define DESCOFF (6)
966 #define VALOFF (8)
967 #define STABSIZE (12)
969 info = (struct stab_find_info *) *pinfo;
970 if (info != NULL)
972 if (info->stabsec == NULL || info->strsec == NULL)
974 /* No stabs debugging information. */
975 return TRUE;
978 stabsize = (info->stabsec->rawsize
979 ? info->stabsec->rawsize
980 : info->stabsec->size);
981 strsize = (info->strsec->rawsize
982 ? info->strsec->rawsize
983 : info->strsec->size);
985 else
987 long reloc_size, reloc_count;
988 arelent **reloc_vector;
989 int i;
990 char *name;
991 char *function_name;
992 bfd_size_type amt = sizeof *info;
994 info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
995 if (info == NULL)
996 return FALSE;
998 /* FIXME: When using the linker --split-by-file or
999 --split-by-reloc options, it is possible for the .stab and
1000 .stabstr sections to be split. We should handle that. */
1002 info->stabsec = bfd_get_section_by_name (abfd, ".stab");
1003 info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
1005 if (info->stabsec == NULL || info->strsec == NULL)
1007 /* Try SOM section names. */
1008 info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
1009 info->strsec = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
1011 if (info->stabsec == NULL || info->strsec == NULL)
1013 /* No stabs debugging information. Set *pinfo so that we
1014 can return quickly in the info != NULL case above. */
1015 *pinfo = info;
1016 return TRUE;
1020 stabsize = (info->stabsec->rawsize
1021 ? info->stabsec->rawsize
1022 : info->stabsec->size);
1023 strsize = (info->strsec->rawsize
1024 ? info->strsec->rawsize
1025 : info->strsec->size);
1027 info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
1028 info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
1029 if (info->stabs == NULL || info->strs == NULL)
1030 return FALSE;
1032 if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1033 0, stabsize)
1034 || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1035 0, strsize))
1036 return FALSE;
1038 /* If this is a relocatable object file, we have to relocate
1039 the entries in .stab. This should always be simple 32 bit
1040 relocations against symbols defined in this object file, so
1041 this should be no big deal. */
1042 reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1043 if (reloc_size < 0)
1044 return FALSE;
1045 reloc_vector = (arelent **) bfd_malloc (reloc_size);
1046 if (reloc_vector == NULL && reloc_size != 0)
1047 return FALSE;
1048 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1049 symbols);
1050 if (reloc_count < 0)
1052 if (reloc_vector != NULL)
1053 free (reloc_vector);
1054 return FALSE;
1056 if (reloc_count > 0)
1058 arelent **pr;
1060 for (pr = reloc_vector; *pr != NULL; pr++)
1062 arelent *r;
1063 unsigned long val;
1064 asymbol *sym;
1066 r = *pr;
1067 /* Ignore R_*_NONE relocs. */
1068 if (r->howto->dst_mask == 0)
1069 continue;
1071 if (r->howto->rightshift != 0
1072 || r->howto->size != 2
1073 || r->howto->bitsize != 32
1074 || r->howto->pc_relative
1075 || r->howto->bitpos != 0
1076 || r->howto->dst_mask != 0xffffffff)
1078 (*_bfd_error_handler)
1079 (_("Unsupported .stab relocation"));
1080 bfd_set_error (bfd_error_invalid_operation);
1081 if (reloc_vector != NULL)
1082 free (reloc_vector);
1083 return FALSE;
1086 val = bfd_get_32 (abfd, info->stabs + r->address);
1087 val &= r->howto->src_mask;
1088 sym = *r->sym_ptr_ptr;
1089 val += sym->value + sym->section->vma + r->addend;
1090 bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1094 if (reloc_vector != NULL)
1095 free (reloc_vector);
1097 /* First time through this function, build a table matching
1098 function VM addresses to stabs, then sort based on starting
1099 VM address. Do this in two passes: once to count how many
1100 table entries we'll need, and a second to actually build the
1101 table. */
1103 info->indextablesize = 0;
1104 saw_fun = 1;
1105 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1107 if (stab[TYPEOFF] == (bfd_byte) N_SO)
1109 /* N_SO with null name indicates EOF */
1110 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1111 continue;
1113 /* if we did not see a function def, leave space for one. */
1114 if (saw_fun == 0)
1115 ++info->indextablesize;
1117 saw_fun = 0;
1119 /* two N_SO's in a row is a filename and directory. Skip */
1120 if (stab + STABSIZE < info->stabs + stabsize
1121 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1123 stab += STABSIZE;
1126 else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1128 saw_fun = 1;
1129 ++info->indextablesize;
1133 if (saw_fun == 0)
1134 ++info->indextablesize;
1136 if (info->indextablesize == 0)
1137 return TRUE;
1138 ++info->indextablesize;
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;
1146 file_name = NULL;
1147 directory_name = NULL;
1148 saw_fun = 1;
1150 for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1151 i < info->indextablesize && stab < info->stabs + stabsize;
1152 stab += STABSIZE)
1154 switch (stab[TYPEOFF])
1156 case 0:
1157 /* This is the first entry in a compilation unit. */
1158 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1159 break;
1160 str += stroff;
1161 stroff = bfd_get_32 (abfd, stab + VALOFF);
1162 break;
1164 case N_SO:
1165 /* The main file name. */
1167 /* The following code creates a new indextable entry with
1168 a NULL function name if there were no N_FUNs in a file.
1169 Note that a N_SO without a file name is an EOF and
1170 there could be 2 N_SO following it with the new filename
1171 and directory. */
1172 if (saw_fun == 0)
1174 info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1175 info->indextable[i].stab = last_stab;
1176 info->indextable[i].str = str;
1177 info->indextable[i].directory_name = directory_name;
1178 info->indextable[i].file_name = file_name;
1179 info->indextable[i].function_name = NULL;
1180 ++i;
1182 saw_fun = 0;
1184 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1185 if (*file_name == '\0')
1187 directory_name = NULL;
1188 file_name = NULL;
1189 saw_fun = 1;
1191 else
1193 last_stab = stab;
1194 if (stab + STABSIZE >= info->stabs + stabsize
1195 || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1197 directory_name = NULL;
1199 else
1201 /* Two consecutive N_SOs are a directory and a
1202 file name. */
1203 stab += STABSIZE;
1204 directory_name = file_name;
1205 file_name = ((char *) str
1206 + bfd_get_32 (abfd, stab + STRDXOFF));
1209 break;
1211 case N_SOL:
1212 /* The name of an include file. */
1213 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1214 break;
1216 case N_FUN:
1217 /* A function name. */
1218 saw_fun = 1;
1219 name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1221 if (*name == '\0')
1222 name = NULL;
1224 function_name = name;
1226 if (name == NULL)
1227 continue;
1229 info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1230 info->indextable[i].stab = stab;
1231 info->indextable[i].str = str;
1232 info->indextable[i].directory_name = directory_name;
1233 info->indextable[i].file_name = file_name;
1234 info->indextable[i].function_name = function_name;
1235 ++i;
1236 break;
1240 if (saw_fun == 0)
1242 info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1243 info->indextable[i].stab = last_stab;
1244 info->indextable[i].str = str;
1245 info->indextable[i].directory_name = directory_name;
1246 info->indextable[i].file_name = file_name;
1247 info->indextable[i].function_name = NULL;
1248 ++i;
1251 info->indextable[i].val = (bfd_vma) -1;
1252 info->indextable[i].stab = info->stabs + stabsize;
1253 info->indextable[i].str = str;
1254 info->indextable[i].directory_name = NULL;
1255 info->indextable[i].file_name = NULL;
1256 info->indextable[i].function_name = NULL;
1257 ++i;
1259 info->indextablesize = i;
1260 qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1261 cmpindexentry);
1263 *pinfo = info;
1266 /* We are passed a section relative offset. The offsets in the
1267 stabs information are absolute. */
1268 offset += bfd_get_section_vma (abfd, section);
1270 #ifdef ENABLE_CACHING
1271 if (info->cached_indexentry != NULL
1272 && offset >= info->cached_offset
1273 && offset < (info->cached_indexentry + 1)->val)
1275 stab = info->cached_stab;
1276 indexentry = info->cached_indexentry;
1277 file_name = info->cached_file_name;
1279 else
1280 #endif
1282 long low, high;
1283 long mid = -1;
1285 /* Cache non-existent or invalid. Do binary search on
1286 indextable. */
1287 indexentry = NULL;
1289 low = 0;
1290 high = info->indextablesize - 1;
1291 while (low != high)
1293 mid = (high + low) / 2;
1294 if (offset >= info->indextable[mid].val
1295 && offset < info->indextable[mid + 1].val)
1297 indexentry = &info->indextable[mid];
1298 break;
1301 if (info->indextable[mid].val > offset)
1302 high = mid;
1303 else
1304 low = mid + 1;
1307 if (indexentry == NULL)
1308 return TRUE;
1310 stab = indexentry->stab + STABSIZE;
1311 file_name = indexentry->file_name;
1314 directory_name = indexentry->directory_name;
1315 str = indexentry->str;
1317 saw_line = FALSE;
1318 saw_func = FALSE;
1319 for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1321 bfd_boolean done;
1322 bfd_vma val;
1324 done = FALSE;
1326 switch (stab[TYPEOFF])
1328 case N_SOL:
1329 /* The name of an include file. */
1330 val = bfd_get_32 (abfd, stab + VALOFF);
1331 if (val <= offset)
1333 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1334 *pline = 0;
1336 break;
1338 case N_SLINE:
1339 case N_DSLINE:
1340 case N_BSLINE:
1341 /* A line number. If the function was specified, then the value
1342 is relative to the start of the function. Otherwise, the
1343 value is an absolute address. */
1344 val = ((indexentry->function_name ? indexentry->val : 0)
1345 + bfd_get_32 (abfd, stab + VALOFF));
1346 /* If this line starts before our desired offset, or if it's
1347 the first line we've been able to find, use it. The
1348 !saw_line check works around a bug in GCC 2.95.3, which emits
1349 the first N_SLINE late. */
1350 if (!saw_line || val <= offset)
1352 *pline = bfd_get_16 (abfd, stab + DESCOFF);
1354 #ifdef ENABLE_CACHING
1355 info->cached_stab = stab;
1356 info->cached_offset = val;
1357 info->cached_file_name = file_name;
1358 info->cached_indexentry = indexentry;
1359 #endif
1361 if (val > offset)
1362 done = TRUE;
1363 saw_line = TRUE;
1364 break;
1366 case N_FUN:
1367 case N_SO:
1368 if (saw_func || saw_line)
1369 done = TRUE;
1370 saw_func = TRUE;
1371 break;
1374 if (done)
1375 break;
1378 *pfound = TRUE;
1380 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1381 || directory_name == NULL)
1382 *pfilename = file_name;
1383 else
1385 size_t dirlen;
1387 dirlen = strlen (directory_name);
1388 if (info->filename == NULL
1389 || strncmp (info->filename, directory_name, dirlen) != 0
1390 || strcmp (info->filename + dirlen, file_name) != 0)
1392 size_t len;
1394 /* Don't free info->filename here. objdump and other
1395 apps keep a copy of a previously returned file name
1396 pointer. */
1397 len = strlen (file_name) + 1;
1398 info->filename = (char *) bfd_alloc (abfd, dirlen + len);
1399 if (info->filename == NULL)
1400 return FALSE;
1401 memcpy (info->filename, directory_name, dirlen);
1402 memcpy (info->filename + dirlen, file_name, len);
1405 *pfilename = info->filename;
1408 if (indexentry->function_name != NULL)
1410 char *s;
1412 /* This will typically be something like main:F(0,1), so we want
1413 to clobber the colon. It's OK to change the name, since the
1414 string is in our own local storage anyhow. */
1415 s = strchr (indexentry->function_name, ':');
1416 if (s != NULL)
1417 *s = '\0';
1419 *pfnname = indexentry->function_name;
1422 return TRUE;