2009-07-22 H.J. Lu <hongjiu.lu@intel.com>
[binutils.git] / bfd / syms.c
blob6abb9294704ca8036c69e61a3349334d8d6131d7
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.
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)
306 . flagword flags;
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;
313 . {* Back end special data. *}
314 . union
316 . void *p;
317 . bfd_vma i;
319 . udata;
321 .asymbol;
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"
333 DOCDD
334 INODE
335 symbol handling functions, , typedef asymbol, Symbols
336 SUBSECTION
337 Symbol handling functions
341 FUNCTION
342 bfd_get_symtab_upper_bound
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.
350 .#define bfd_get_symtab_upper_bound(abfd) \
351 . BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
356 FUNCTION
357 bfd_is_local_label
359 SYNOPSIS
360 bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
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.
367 bfd_boolean
368 bfd_is_local_label (bfd *abfd, asymbol *sym)
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);
381 FUNCTION
382 bfd_is_local_label_name
384 SYNOPSIS
385 bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
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.
393 .#define bfd_is_local_label_name(abfd, name) \
394 . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
399 FUNCTION
400 bfd_is_target_special_symbol
402 SYNOPSIS
403 bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
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.
410 .#define bfd_is_target_special_symbol(abfd, sym) \
411 . BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
416 FUNCTION
417 bfd_canonicalize_symtab
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.
426 .#define bfd_canonicalize_symtab(abfd, location) \
427 . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
432 FUNCTION
433 bfd_set_symtab
435 SYNOPSIS
436 bfd_boolean bfd_set_symtab
437 (bfd *abfd, asymbol **location, unsigned int count);
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.
445 bfd_boolean
446 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
448 if (abfd->format != bfd_object || bfd_read_p (abfd))
450 bfd_set_error (bfd_error_invalid_operation);
451 return FALSE;
454 bfd_get_outsymbols (abfd) = location;
455 bfd_get_symcount (abfd) = symcount;
456 return TRUE;
460 FUNCTION
461 bfd_print_symbol_vandf
463 SYNOPSIS
464 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
466 DESCRIPTION
467 Print the value and flags of the @var{symbol} supplied to the
468 stream @var{file}.
470 void
471 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
473 FILE *file = arg;
475 flagword type = symbol->flags;
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);
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' : ' '))));
502 FUNCTION
503 bfd_make_empty_symbol
505 DESCRIPTION
506 Create a new <<asymbol>> structure for the BFD @var{abfd}
507 and return a pointer to it.
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.
514 .#define bfd_make_empty_symbol(abfd) \
515 . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
520 FUNCTION
521 _bfd_generic_make_empty_symbol
523 SYNOPSIS
524 asymbol *_bfd_generic_make_empty_symbol (bfd *);
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.
533 asymbol *
534 _bfd_generic_make_empty_symbol (bfd *abfd)
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;
544 FUNCTION
545 bfd_make_debug_symbol
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.
552 .#define bfd_make_debug_symbol(abfd,ptr,size) \
553 . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
557 struct section_to_type
559 const char *section;
560 char type;
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[] =
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}
590 /* Return the single-character symbol type corresponding to
591 section S, or '?' for an unknown COFF section.
593 Check for any leading string which matches, so .text5 returns
594 't' as well as .text */
596 static char
597 coff_section_type (const char *s)
599 const struct section_to_type *t;
601 for (t = &stt[0]; t->section; t++)
602 if (!strncmp (s, t->section, strlen (t->section)))
603 return t->type;
605 return '?';
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.
612 FIXME These types are unhandled: c, i, e, p. If we handled these also,
613 we could perhaps obsolete coff_section_type. */
615 static char
616 decode_section_type (const struct bfd_section *section)
618 if (section->flags & SEC_CODE)
619 return 't';
620 if (section->flags & SEC_DATA)
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';
629 if ((section->flags & SEC_HAS_CONTENTS) == 0)
631 if (section->flags & SEC_SMALL_DATA)
632 return 's';
633 else
634 return 'b';
636 if (section->flags & SEC_DEBUGGING)
637 return 'N';
638 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
639 return 'n';
641 return '?';
645 FUNCTION
646 bfd_decode_symclass
648 DESCRIPTION
649 Return a character corresponding to the symbol
650 class of @var{symbol}, or '?' for an unknown class.
652 SYNOPSIS
653 int bfd_decode_symclass (asymbol *symbol);
656 bfd_decode_symclass (asymbol *symbol)
658 char c;
660 if (symbol->section && bfd_is_com_section (symbol->section))
661 return 'C';
662 if (bfd_is_und_section (symbol->section))
664 if (symbol->flags & BSF_WEAK)
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';
673 else
674 return 'U';
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)
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';
689 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
690 return '?';
692 if (bfd_is_abs_section (symbol->section))
693 c = 'a';
694 else if (symbol->section)
696 c = coff_section_type (symbol->section->name);
697 if (c == '?')
698 c = decode_section_type (symbol->section);
700 else
701 return '?';
702 if (symbol->flags & BSF_GLOBAL)
703 c = TOUPPER (c);
704 return c;
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';
717 FUNCTION
718 bfd_is_undefined_symclass
720 DESCRIPTION
721 Returns non-zero if the class symbol returned by
722 bfd_decode_symclass represents an undefined symbol.
723 Returns zero otherwise.
725 SYNOPSIS
726 bfd_boolean bfd_is_undefined_symclass (int symclass);
729 bfd_boolean
730 bfd_is_undefined_symclass (int symclass)
732 return symclass == 'U' || symclass == 'w' || symclass == 'v';
736 FUNCTION
737 bfd_symbol_info
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.
744 SYNOPSIS
745 void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
748 void
749 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
751 ret->type = bfd_decode_symclass (symbol);
753 if (bfd_is_undefined_symclass (ret->type))
754 ret->value = 0;
755 else
756 ret->value = symbol->value + symbol->section->vma;
758 ret->name = symbol->name;
762 FUNCTION
763 bfd_copy_private_symbol_data
765 SYNOPSIS
766 bfd_boolean bfd_copy_private_symbol_data
767 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
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:
775 o <<bfd_error_no_memory>> -
776 Not enough memory exists to create private data for @var{osec}.
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))
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. */
788 long
789 _bfd_generic_read_minisymbols (bfd *abfd,
790 bfd_boolean dynamic,
791 void **minisymsp,
792 unsigned int *sizep)
794 long storage;
795 asymbol **syms = NULL;
796 long symcount;
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;
807 syms = bfd_malloc (storage);
808 if (syms == NULL)
809 goto error_return;
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;
818 *minisymsp = syms;
819 *sizep = sizeof (asymbol *);
820 return symcount;
822 error_return:
823 bfd_set_error (bfd_error_no_symbols);
824 if (syms != NULL)
825 free (syms);
826 return -1;
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. */
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)
839 return *(asymbol **) minisym;
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. */
851 /* We use a cache by default. */
853 #define ENABLE_CACHING
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. */
859 struct indexentry
861 bfd_vma val;
862 bfd_byte *stab;
863 bfd_byte *str;
864 char *directory_name;
865 char *file_name;
866 char *function_name;
869 /* Compare two indexentry structures. This is called via qsort. */
871 static int
872 cmpindexentry (const void *a, const void *b)
874 const struct indexentry *contestantA = a;
875 const struct indexentry *contestantB = b;
877 if (contestantA->val < contestantB->val)
878 return -1;
879 else if (contestantA->val > contestantB->val)
880 return 1;
881 else
882 return 0;
885 /* A pointer to this structure is stored in *pinfo. */
887 struct stab_find_info
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;
898 /* A table that indexes stabs by memory address. */
899 struct indexentry *indextable;
900 /* The number of entries in indextable. */
901 int indextablesize;
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
911 /* Saved ptr to malloc'ed filename. */
912 char *filename;
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)
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;
937 *pfound = FALSE;
938 *pfilename = bfd_get_filename (abfd);
939 *pfnname = NULL;
940 *pline = 0;
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.
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. */
955 #define STRDXOFF (0)
956 #define TYPEOFF (4)
957 #define OTHEROFF (5)
958 #define DESCOFF (6)
959 #define VALOFF (8)
960 #define STABSIZE (12)
962 info = *pinfo;
963 if (info != NULL)
965 if (info->stabsec == NULL || info->strsec == NULL)
967 /* No stabs debugging information. */
968 return TRUE;
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);
978 else
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;
987 info = bfd_zalloc (abfd, amt);
988 if (info == NULL)
989 return FALSE;
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. */
995 info->stabsec = bfd_get_section_by_name (abfd, ".stab");
996 info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
998 if (info->stabsec == NULL || info->strsec == NULL)
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$");
1004 if (info->stabsec == NULL || info->strsec == NULL)
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;
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);
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;
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;
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)
1045 if (reloc_vector != NULL)
1046 free (reloc_vector);
1047 return FALSE;
1049 if (reloc_count > 0)
1051 arelent **pr;
1053 for (pr = reloc_vector; *pr != NULL; pr++)
1055 arelent *r;
1056 unsigned long val;
1057 asymbol *sym;
1059 r = *pr;
1060 /* Ignore R_*_NONE relocs. */
1061 if (r->howto->dst_mask == 0)
1062 continue;
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)
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;
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);
1087 if (reloc_vector != NULL)
1088 free (reloc_vector);
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. */
1096 info->indextablesize = 0;
1097 saw_fun = 1;
1098 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1100 if (stab[TYPEOFF] == (bfd_byte) N_SO)
1102 /* N_SO with null name indicates EOF */
1103 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1104 continue;
1106 /* if we did not see a function def, leave space for one. */
1107 if (saw_fun == 0)
1108 ++info->indextablesize;
1110 saw_fun = 0;
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)
1116 stab += STABSIZE;
1119 else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1121 saw_fun = 1;
1122 ++info->indextablesize;
1126 if (saw_fun == 0)
1127 ++info->indextablesize;
1129 if (info->indextablesize == 0)
1130 return TRUE;
1131 ++info->indextablesize;
1133 amt = info->indextablesize;
1134 amt *= sizeof (struct indexentry);
1135 info->indextable = bfd_alloc (abfd, amt);
1136 if (info->indextable == NULL)
1137 return FALSE;
1139 file_name = NULL;
1140 directory_name = NULL;
1141 saw_fun = 1;
1143 for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1144 i < info->indextablesize && stab < info->stabs + stabsize;
1145 stab += STABSIZE)
1147 switch (stab[TYPEOFF])
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;
1157 case N_SO:
1158 /* The main file name. */
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)
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;
1175 saw_fun = 0;
1177 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1178 if (*file_name == '\0')
1180 directory_name = NULL;
1181 file_name = NULL;
1182 saw_fun = 1;
1184 else
1186 last_stab = stab;
1187 if (stab + STABSIZE >= info->stabs + stabsize
1188 || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1190 directory_name = NULL;
1192 else
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));
1202 break;
1204 case N_SOL:
1205 /* The name of an include file. */
1206 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1207 break;
1209 case N_FUN:
1210 /* A function name. */
1211 saw_fun = 1;
1212 name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1214 if (*name == '\0')
1215 name = NULL;
1217 function_name = name;
1219 if (name == NULL)
1220 continue;
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;
1233 if (saw_fun == 0)
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;
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;
1252 info->indextablesize = i;
1253 qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1254 cmpindexentry);
1256 *pinfo = info;
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);
1263 #ifdef ENABLE_CACHING
1264 if (info->cached_indexentry != NULL
1265 && offset >= info->cached_offset
1266 && offset < (info->cached_indexentry + 1)->val)
1268 stab = info->cached_stab;
1269 indexentry = info->cached_indexentry;
1270 file_name = info->cached_file_name;
1272 else
1273 #endif
1275 long low, high;
1276 long mid = -1;
1278 /* Cache non-existent or invalid. Do binary search on
1279 indextable. */
1280 indexentry = NULL;
1282 low = 0;
1283 high = info->indextablesize - 1;
1284 while (low != high)
1286 mid = (high + low) / 2;
1287 if (offset >= info->indextable[mid].val
1288 && offset < info->indextable[mid + 1].val)
1290 indexentry = &info->indextable[mid];
1291 break;
1294 if (info->indextable[mid].val > offset)
1295 high = mid;
1296 else
1297 low = mid + 1;
1300 if (indexentry == NULL)
1301 return TRUE;
1303 stab = indexentry->stab + STABSIZE;
1304 file_name = indexentry->file_name;
1307 directory_name = indexentry->directory_name;
1308 str = indexentry->str;
1310 saw_line = FALSE;
1311 saw_func = FALSE;
1312 for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1314 bfd_boolean done;
1315 bfd_vma val;
1317 done = FALSE;
1319 switch (stab[TYPEOFF])
1321 case N_SOL:
1322 /* The name of an include file. */
1323 val = bfd_get_32 (abfd, stab + VALOFF);
1324 if (val <= offset)
1326 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1327 *pline = 0;
1329 break;
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)
1345 *pline = bfd_get_16 (abfd, stab + DESCOFF);
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
1354 if (val > offset)
1355 done = TRUE;
1356 saw_line = TRUE;
1357 break;
1359 case N_FUN:
1360 case N_SO:
1361 if (saw_func || saw_line)
1362 done = TRUE;
1363 saw_func = TRUE;
1364 break;
1367 if (done)
1368 break;
1371 *pfound = TRUE;
1373 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1374 || directory_name == NULL)
1375 *pfilename = file_name;
1376 else
1378 size_t dirlen;
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)
1385 size_t len;
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);
1398 *pfilename = info->filename;
1401 if (indexentry->function_name != NULL)
1403 char *s;
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';
1412 *pfnname = indexentry->function_name;
1415 return TRUE;