daily update
[binutils.git] / bfd / syms.c
blobc07f48b4a9a6bea09daedb94dc244c3b5b210c73
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
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 SECTION
25 Symbols
27 BFD tries to maintain as much symbol information as it can when
28 it moves information from file to file. BFD passes information
29 to applications though the <<asymbol>> structure. When the
30 application requests the symbol table, BFD reads the table in
31 the native form and translates parts of it into the internal
32 format. To maintain more than the information passed to
33 applications, some targets keep some information ``behind the
34 scenes'' in a structure only the particular back end knows
35 about. For example, the coff back end keeps the original
36 symbol table structure as well as the canonical structure when
37 a BFD is read in. On output, the coff back end can reconstruct
38 the output symbol table so that no information is lost, even
39 information unique to coff which BFD doesn't know or
40 understand. If a coff symbol table were read, but were written
41 through an a.out back end, all the coff specific information
42 would be lost. The symbol table of a BFD
43 is not necessarily read in until a canonicalize request is
44 made. Then the BFD back end fills in a table provided by the
45 application with pointers to the canonical information. To
46 output symbols, the application provides BFD with a table of
47 pointers to pointers to <<asymbol>>s. This allows applications
48 like the linker to output a symbol as it was read, since the ``behind
49 the scenes'' information will be still available.
50 @menu
51 @* Reading Symbols::
52 @* Writing Symbols::
53 @* Mini Symbols::
54 @* typedef asymbol::
55 @* symbol handling functions::
56 @end menu
58 INODE
59 Reading Symbols, Writing Symbols, Symbols, Symbols
60 SUBSECTION
61 Reading symbols
63 There are two stages to reading a symbol table from a BFD:
64 allocating storage, and the actual reading process. This is an
65 excerpt from an application which reads the symbol table:
67 | long storage_needed;
68 | asymbol **symbol_table;
69 | long number_of_symbols;
70 | long i;
72 | storage_needed = bfd_get_symtab_upper_bound (abfd);
74 | if (storage_needed < 0)
75 | FAIL
77 | if (storage_needed == 0)
78 | return;
80 | symbol_table = xmalloc (storage_needed);
81 | ...
82 | number_of_symbols =
83 | bfd_canonicalize_symtab (abfd, symbol_table);
85 | if (number_of_symbols < 0)
86 | FAIL
88 | for (i = 0; i < number_of_symbols; i++)
89 | process_symbol (symbol_table[i]);
91 All storage for the symbols themselves is in an objalloc
92 connected to the BFD; it is freed when the BFD is closed.
94 INODE
95 Writing Symbols, Mini Symbols, Reading Symbols, Symbols
96 SUBSECTION
97 Writing symbols
99 Writing of a symbol table is automatic when a BFD open for
100 writing is closed. The application attaches a vector of
101 pointers to pointers to symbols to the BFD being written, and
102 fills in the symbol count. The close and cleanup code reads
103 through the table provided and performs all the necessary
104 operations. The BFD output code must always be provided with an
105 ``owned'' symbol: one which has come from another BFD, or one
106 which has been created using <<bfd_make_empty_symbol>>. Here is an
107 example showing the creation of a symbol table with only one element:
109 | #include "bfd.h"
110 | int main (void)
112 | bfd *abfd;
113 | asymbol *ptrs[2];
114 | asymbol *new;
116 | abfd = bfd_openw ("foo","a.out-sunos-big");
117 | bfd_set_format (abfd, bfd_object);
118 | new = bfd_make_empty_symbol (abfd);
119 | new->name = "dummy_symbol";
120 | new->section = bfd_make_section_old_way (abfd, ".text");
121 | new->flags = BSF_GLOBAL;
122 | new->value = 0x12345;
124 | ptrs[0] = new;
125 | ptrs[1] = 0;
127 | bfd_set_symtab (abfd, ptrs, 1);
128 | bfd_close (abfd);
129 | return 0;
132 | ./makesym
133 | nm foo
134 | 00012345 A dummy_symbol
136 Many formats cannot represent arbitrary symbol information; for
137 instance, the <<a.out>> object format does not allow an
138 arbitrary number of sections. A symbol pointing to a section
139 which is not one of <<.text>>, <<.data>> or <<.bss>> cannot
140 be described.
142 INODE
143 Mini Symbols, typedef asymbol, Writing Symbols, Symbols
144 SUBSECTION
145 Mini Symbols
147 Mini symbols provide read-only access to the symbol table.
148 They use less memory space, but require more time to access.
149 They can be useful for tools like nm or objdump, which may
150 have to handle symbol tables of extremely large executables.
152 The <<bfd_read_minisymbols>> function will read the symbols
153 into memory in an internal form. It will return a <<void *>>
154 pointer to a block of memory, a symbol count, and the size of
155 each symbol. The pointer is allocated using <<malloc>>, and
156 should be freed by the caller when it is no longer needed.
158 The function <<bfd_minisymbol_to_symbol>> will take a pointer
159 to a minisymbol, and a pointer to a structure returned by
160 <<bfd_make_empty_symbol>>, and return a <<asymbol>> structure.
161 The return value may or may not be the same as the value from
162 <<bfd_make_empty_symbol>> which was passed in.
167 DOCDD
168 INODE
169 typedef asymbol, symbol handling functions, Mini Symbols, Symbols
173 SUBSECTION
174 typedef asymbol
176 An <<asymbol>> has the form:
181 CODE_FRAGMENT
184 .typedef struct bfd_symbol
186 . {* A pointer to the BFD which owns the symbol. This information
187 . is necessary so that a back end can work out what additional
188 . information (invisible to the application writer) is carried
189 . with the symbol.
191 . This field is *almost* redundant, since you can use section->owner
192 . instead, except that some symbols point to the global sections
193 . bfd_{abs,com,und}_section. This could be fixed by making
194 . these globals be per-bfd (or per-target-flavor). FIXME. *}
195 . struct bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *}
197 . {* The text of the symbol. The name is left alone, and not copied; the
198 . application may not alter it. *}
199 . const char *name;
201 . {* The value of the symbol. This really should be a union of a
202 . numeric value with a pointer, since some flags indicate that
203 . a pointer to another symbol is stored here. *}
204 . symvalue value;
206 . {* Attributes of a symbol. *}
207 .#define BSF_NO_FLAGS 0x00
209 . {* The symbol has local scope; <<static>> in <<C>>. The value
210 . is the offset into the section of the data. *}
211 .#define BSF_LOCAL 0x01
213 . {* The symbol has global scope; initialized data in <<C>>. The
214 . value is the offset into the section of the data. *}
215 .#define BSF_GLOBAL 0x02
217 . {* The symbol has global scope and is exported. The value is
218 . the offset into the section of the data. *}
219 .#define BSF_EXPORT BSF_GLOBAL {* No real difference. *}
221 . {* A normal C symbol would be one of:
222 . <<BSF_LOCAL>>, <<BSF_FORT_COMM>>, <<BSF_UNDEFINED>> or
223 . <<BSF_GLOBAL>>. *}
225 . {* The symbol is a debugging record. The value has an arbitrary
226 . meaning, unless BSF_DEBUGGING_RELOC is also set. *}
227 .#define BSF_DEBUGGING 0x08
229 . {* The symbol denotes a function entry point. Used in ELF,
230 . perhaps others someday. *}
231 .#define BSF_FUNCTION 0x10
233 . {* Used by the linker. *}
234 .#define BSF_KEEP 0x20
235 .#define BSF_KEEP_G 0x40
237 . {* A weak global symbol, overridable without warnings by
238 . a regular global symbol of the same name. *}
239 .#define BSF_WEAK 0x80
241 . {* This symbol was created to point to a section, e.g. ELF's
242 . STT_SECTION symbols. *}
243 .#define BSF_SECTION_SYM 0x100
245 . {* The symbol used to be a common symbol, but now it is
246 . allocated. *}
247 .#define BSF_OLD_COMMON 0x200
249 . {* The default value for common data. *}
250 .#define BFD_FORT_COMM_DEFAULT_VALUE 0
252 . {* In some files the type of a symbol sometimes alters its
253 . location in an output file - ie in coff a <<ISFCN>> symbol
254 . which is also <<C_EXT>> symbol appears where it was
255 . declared and not at the end of a section. This bit is set
256 . by the target BFD part to convey this information. *}
257 .#define BSF_NOT_AT_END 0x400
259 . {* Signal that the symbol is the label of constructor section. *}
260 .#define BSF_CONSTRUCTOR 0x800
262 . {* Signal that the symbol is a warning symbol. The name is a
263 . warning. The name of the next symbol is the one to warn about;
264 . if a reference is made to a symbol with the same name as the next
265 . symbol, a warning is issued by the linker. *}
266 .#define BSF_WARNING 0x1000
268 . {* Signal that the symbol is indirect. This symbol is an indirect
269 . pointer to the symbol with the same name as the next symbol. *}
270 .#define BSF_INDIRECT 0x2000
272 . {* BSF_FILE marks symbols that contain a file name. This is used
273 . for ELF STT_FILE symbols. *}
274 .#define BSF_FILE 0x4000
276 . {* Symbol is from dynamic linking information. *}
277 .#define BSF_DYNAMIC 0x8000
279 . {* The symbol denotes a data object. Used in ELF, and perhaps
280 . others someday. *}
281 .#define BSF_OBJECT 0x10000
283 . {* This symbol is a debugging symbol. The value is the offset
284 . into the section of the data. BSF_DEBUGGING should be set
285 . as well. *}
286 .#define BSF_DEBUGGING_RELOC 0x20000
288 . {* This symbol is thread local. Used in ELF. *}
289 .#define BSF_THREAD_LOCAL 0x40000
291 . flagword flags;
293 . {* A pointer to the section to which this symbol is
294 . relative. This will always be non NULL, there are special
295 . sections for undefined and absolute symbols. *}
296 . struct bfd_section *section;
298 . {* Back end special data. *}
299 . union
301 . void *p;
302 . bfd_vma i;
304 . udata;
306 .asymbol;
310 #include "bfd.h"
311 #include "sysdep.h"
312 #include "libbfd.h"
313 #include "safe-ctype.h"
314 #include "bfdlink.h"
315 #include "aout/stab_gnu.h"
318 DOCDD
319 INODE
320 symbol handling functions, , typedef asymbol, Symbols
321 SUBSECTION
322 Symbol handling functions
326 FUNCTION
327 bfd_get_symtab_upper_bound
329 DESCRIPTION
330 Return the number of bytes required to store a vector of pointers
331 to <<asymbols>> for all the symbols in the BFD @var{abfd},
332 including a terminal NULL pointer. If there are no symbols in
333 the BFD, then return 0. If an error occurs, return -1.
335 .#define bfd_get_symtab_upper_bound(abfd) \
336 . BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
341 FUNCTION
342 bfd_is_local_label
344 SYNOPSIS
345 bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
347 DESCRIPTION
348 Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
349 a compiler generated local label, else return FALSE.
352 bfd_boolean
353 bfd_is_local_label (bfd *abfd, asymbol *sym)
355 /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
356 starts with '.' is local. This would accidentally catch section names
357 if we didn't reject them here. */
358 if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_SECTION_SYM)) != 0)
359 return FALSE;
360 if (sym->name == NULL)
361 return FALSE;
362 return bfd_is_local_label_name (abfd, sym->name);
366 FUNCTION
367 bfd_is_local_label_name
369 SYNOPSIS
370 bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
372 DESCRIPTION
373 Return TRUE if a symbol with the name @var{name} in the BFD
374 @var{abfd} is a compiler generated local label, else return
375 FALSE. This just checks whether the name has the form of a
376 local label.
378 .#define bfd_is_local_label_name(abfd, name) \
379 . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
384 FUNCTION
385 bfd_canonicalize_symtab
387 DESCRIPTION
388 Read the symbols from the BFD @var{abfd}, and fills in
389 the vector @var{location} with pointers to the symbols and
390 a trailing NULL.
391 Return the actual number of symbol pointers, not
392 including the NULL.
394 .#define bfd_canonicalize_symtab(abfd, location) \
395 . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
400 FUNCTION
401 bfd_set_symtab
403 SYNOPSIS
404 bfd_boolean bfd_set_symtab
405 (bfd *abfd, asymbol **location, unsigned int count);
407 DESCRIPTION
408 Arrange that when the output BFD @var{abfd} is closed,
409 the table @var{location} of @var{count} pointers to symbols
410 will be written.
413 bfd_boolean
414 bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
416 if (abfd->format != bfd_object || bfd_read_p (abfd))
418 bfd_set_error (bfd_error_invalid_operation);
419 return FALSE;
422 bfd_get_outsymbols (abfd) = location;
423 bfd_get_symcount (abfd) = symcount;
424 return TRUE;
428 FUNCTION
429 bfd_print_symbol_vandf
431 SYNOPSIS
432 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
434 DESCRIPTION
435 Print the value and flags of the @var{symbol} supplied to the
436 stream @var{file}.
438 void
439 bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
441 FILE *file = arg;
443 flagword type = symbol->flags;
445 if (symbol->section != NULL)
446 bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
447 else
448 bfd_fprintf_vma (abfd, file, symbol->value);
450 /* This presumes that a symbol can not be both BSF_DEBUGGING and
451 BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
452 BSF_OBJECT. */
453 fprintf (file, " %c%c%c%c%c%c%c",
454 ((type & BSF_LOCAL)
455 ? (type & BSF_GLOBAL) ? '!' : 'l'
456 : (type & BSF_GLOBAL) ? 'g' : ' '),
457 (type & BSF_WEAK) ? 'w' : ' ',
458 (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
459 (type & BSF_WARNING) ? 'W' : ' ',
460 (type & BSF_INDIRECT) ? 'I' : ' ',
461 (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
462 ((type & BSF_FUNCTION)
463 ? 'F'
464 : ((type & BSF_FILE)
465 ? 'f'
466 : ((type & BSF_OBJECT) ? 'O' : ' '))));
470 FUNCTION
471 bfd_make_empty_symbol
473 DESCRIPTION
474 Create a new <<asymbol>> structure for the BFD @var{abfd}
475 and return a pointer to it.
477 This routine is necessary because each back end has private
478 information surrounding the <<asymbol>>. Building your own
479 <<asymbol>> and pointing to it will not create the private
480 information, and will cause problems later on.
482 .#define bfd_make_empty_symbol(abfd) \
483 . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
488 FUNCTION
489 _bfd_generic_make_empty_symbol
491 SYNOPSIS
492 asymbol *_bfd_generic_make_empty_symbol (bfd *);
494 DESCRIPTION
495 Create a new <<asymbol>> structure for the BFD @var{abfd}
496 and return a pointer to it. Used by core file routines,
497 binary back-end and anywhere else where no private info
498 is needed.
501 asymbol *
502 _bfd_generic_make_empty_symbol (bfd *abfd)
504 bfd_size_type amt = sizeof (asymbol);
505 asymbol *new = bfd_zalloc (abfd, amt);
506 if (new)
507 new->the_bfd = abfd;
508 return new;
512 FUNCTION
513 bfd_make_debug_symbol
515 DESCRIPTION
516 Create a new <<asymbol>> structure for the BFD @var{abfd},
517 to be used as a debugging symbol. Further details of its use have
518 yet to be worked out.
520 .#define bfd_make_debug_symbol(abfd,ptr,size) \
521 . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
525 struct section_to_type
527 const char *section;
528 char type;
531 /* Map section names to POSIX/BSD single-character symbol types.
532 This table is probably incomplete. It is sorted for convenience of
533 adding entries. Since it is so short, a linear search is used. */
534 static const struct section_to_type stt[] =
536 {".bss", 'b'},
537 {"code", 't'}, /* MRI .text */
538 {".data", 'd'},
539 {"*DEBUG*", 'N'},
540 {".debug", 'N'}, /* MSVC's .debug (non-standard debug syms) */
541 {".drectve", 'i'}, /* MSVC's .drective section */
542 {".edata", 'e'}, /* MSVC's .edata (export) section */
543 {".fini", 't'}, /* ELF fini section */
544 {".idata", 'i'}, /* MSVC's .idata (import) section */
545 {".init", 't'}, /* ELF init section */
546 {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */
547 {".rdata", 'r'}, /* Read only data. */
548 {".rodata", 'r'}, /* Read only data. */
549 {".sbss", 's'}, /* Small BSS (uninitialized data). */
550 {".scommon", 'c'}, /* Small common. */
551 {".sdata", 'g'}, /* Small initialized data. */
552 {".text", 't'},
553 {"vars", 'd'}, /* MRI .data */
554 {"zerovars", 'b'}, /* MRI .bss */
555 {0, 0}
558 /* Return the single-character symbol type corresponding to
559 section S, or '?' for an unknown COFF section.
561 Check for any leading string which matches, so .text5 returns
562 't' as well as .text */
564 static char
565 coff_section_type (const char *s)
567 const struct section_to_type *t;
569 for (t = &stt[0]; t->section; t++)
570 if (!strncmp (s, t->section, strlen (t->section)))
571 return t->type;
573 return '?';
576 /* Return the single-character symbol type corresponding to section
577 SECTION, or '?' for an unknown section. This uses section flags to
578 identify sections.
580 FIXME These types are unhandled: c, i, e, p. If we handled these also,
581 we could perhaps obsolete coff_section_type. */
583 static char
584 decode_section_type (const struct bfd_section *section)
586 if (section->flags & SEC_CODE)
587 return 't';
588 if (section->flags & SEC_DATA)
590 if (section->flags & SEC_READONLY)
591 return 'r';
592 else if (section->flags & SEC_SMALL_DATA)
593 return 'g';
594 else
595 return 'd';
597 if ((section->flags & SEC_HAS_CONTENTS) == 0)
599 if (section->flags & SEC_SMALL_DATA)
600 return 's';
601 else
602 return 'b';
604 if (section->flags & SEC_DEBUGGING)
605 return 'N';
606 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
607 return 'n';
609 return '?';
613 FUNCTION
614 bfd_decode_symclass
616 DESCRIPTION
617 Return a character corresponding to the symbol
618 class of @var{symbol}, or '?' for an unknown class.
620 SYNOPSIS
621 int bfd_decode_symclass (asymbol *symbol);
624 bfd_decode_symclass (asymbol *symbol)
626 char c;
628 if (bfd_is_com_section (symbol->section))
629 return 'C';
630 if (bfd_is_und_section (symbol->section))
632 if (symbol->flags & BSF_WEAK)
634 /* If weak, determine if it's specifically an object
635 or non-object weak. */
636 if (symbol->flags & BSF_OBJECT)
637 return 'v';
638 else
639 return 'w';
641 else
642 return 'U';
644 if (bfd_is_ind_section (symbol->section))
645 return 'I';
646 if (symbol->flags & BSF_WEAK)
648 /* If weak, determine if it's specifically an object
649 or non-object weak. */
650 if (symbol->flags & BSF_OBJECT)
651 return 'V';
652 else
653 return 'W';
655 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
656 return '?';
658 if (bfd_is_abs_section (symbol->section))
659 c = 'a';
660 else if (symbol->section)
662 c = coff_section_type (symbol->section->name);
663 if (c == '?')
664 c = decode_section_type (symbol->section);
666 else
667 return '?';
668 if (symbol->flags & BSF_GLOBAL)
669 c = TOUPPER (c);
670 return c;
672 /* We don't have to handle these cases just yet, but we will soon:
673 N_SETV: 'v';
674 N_SETA: 'l';
675 N_SETT: 'x';
676 N_SETD: 'z';
677 N_SETB: 's';
678 N_INDR: 'i';
683 FUNCTION
684 bfd_is_undefined_symclass
686 DESCRIPTION
687 Returns non-zero if the class symbol returned by
688 bfd_decode_symclass represents an undefined symbol.
689 Returns zero otherwise.
691 SYNOPSIS
692 bfd_boolean bfd_is_undefined_symclass (int symclass);
695 bfd_boolean
696 bfd_is_undefined_symclass (int symclass)
698 return symclass == 'U' || symclass == 'w' || symclass == 'v';
702 FUNCTION
703 bfd_symbol_info
705 DESCRIPTION
706 Fill in the basic info about symbol that nm needs.
707 Additional info may be added by the back-ends after
708 calling this function.
710 SYNOPSIS
711 void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
714 void
715 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
717 ret->type = bfd_decode_symclass (symbol);
719 if (bfd_is_undefined_symclass (ret->type))
720 ret->value = 0;
721 else
722 ret->value = symbol->value + symbol->section->vma;
724 ret->name = symbol->name;
728 FUNCTION
729 bfd_copy_private_symbol_data
731 SYNOPSIS
732 bfd_boolean bfd_copy_private_symbol_data
733 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
735 DESCRIPTION
736 Copy private symbol information from @var{isym} in the BFD
737 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
738 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
739 returns are:
741 o <<bfd_error_no_memory>> -
742 Not enough memory exists to create private data for @var{osec}.
744 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
745 . BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
746 . (ibfd, isymbol, obfd, osymbol))
750 /* The generic version of the function which returns mini symbols.
751 This is used when the backend does not provide a more efficient
752 version. It just uses BFD asymbol structures as mini symbols. */
754 long
755 _bfd_generic_read_minisymbols (bfd *abfd,
756 bfd_boolean dynamic,
757 void **minisymsp,
758 unsigned int *sizep)
760 long storage;
761 asymbol **syms = NULL;
762 long symcount;
764 if (dynamic)
765 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
766 else
767 storage = bfd_get_symtab_upper_bound (abfd);
768 if (storage < 0)
769 goto error_return;
770 if (storage == 0)
771 return 0;
773 syms = bfd_malloc (storage);
774 if (syms == NULL)
775 goto error_return;
777 if (dynamic)
778 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
779 else
780 symcount = bfd_canonicalize_symtab (abfd, syms);
781 if (symcount < 0)
782 goto error_return;
784 *minisymsp = syms;
785 *sizep = sizeof (asymbol *);
786 return symcount;
788 error_return:
789 bfd_set_error (bfd_error_no_symbols);
790 if (syms != NULL)
791 free (syms);
792 return -1;
795 /* The generic version of the function which converts a minisymbol to
796 an asymbol. We don't worry about the sym argument we are passed;
797 we just return the asymbol the minisymbol points to. */
799 asymbol *
800 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
801 bfd_boolean dynamic ATTRIBUTE_UNUSED,
802 const void *minisym,
803 asymbol *sym ATTRIBUTE_UNUSED)
805 return *(asymbol **) minisym;
808 /* Look through stabs debugging information in .stab and .stabstr
809 sections to find the source file and line closest to a desired
810 location. This is used by COFF and ELF targets. It sets *pfound
811 to TRUE if it finds some information. The *pinfo field is used to
812 pass cached information in and out of this routine; this first time
813 the routine is called for a BFD, *pinfo should be NULL. The value
814 placed in *pinfo should be saved with the BFD, and passed back each
815 time this function is called. */
817 /* We use a cache by default. */
819 #define ENABLE_CACHING
821 /* We keep an array of indexentry structures to record where in the
822 stabs section we should look to find line number information for a
823 particular address. */
825 struct indexentry
827 bfd_vma val;
828 bfd_byte *stab;
829 bfd_byte *str;
830 char *directory_name;
831 char *file_name;
832 char *function_name;
835 /* Compare two indexentry structures. This is called via qsort. */
837 static int
838 cmpindexentry (const void *a, const void *b)
840 const struct indexentry *contestantA = a;
841 const struct indexentry *contestantB = b;
843 if (contestantA->val < contestantB->val)
844 return -1;
845 else if (contestantA->val > contestantB->val)
846 return 1;
847 else
848 return 0;
851 /* A pointer to this structure is stored in *pinfo. */
853 struct stab_find_info
855 /* The .stab section. */
856 asection *stabsec;
857 /* The .stabstr section. */
858 asection *strsec;
859 /* The contents of the .stab section. */
860 bfd_byte *stabs;
861 /* The contents of the .stabstr section. */
862 bfd_byte *strs;
864 /* A table that indexes stabs by memory address. */
865 struct indexentry *indextable;
866 /* The number of entries in indextable. */
867 int indextablesize;
869 #ifdef ENABLE_CACHING
870 /* Cached values to restart quickly. */
871 struct indexentry *cached_indexentry;
872 bfd_vma cached_offset;
873 bfd_byte *cached_stab;
874 char *cached_file_name;
875 #endif
877 /* Saved ptr to malloc'ed filename. */
878 char *filename;
881 bfd_boolean
882 _bfd_stab_section_find_nearest_line (bfd *abfd,
883 asymbol **symbols,
884 asection *section,
885 bfd_vma offset,
886 bfd_boolean *pfound,
887 const char **pfilename,
888 const char **pfnname,
889 unsigned int *pline,
890 void **pinfo)
892 struct stab_find_info *info;
893 bfd_size_type stabsize, strsize;
894 bfd_byte *stab, *str;
895 bfd_byte *last_stab = NULL;
896 bfd_size_type stroff;
897 struct indexentry *indexentry;
898 char *file_name;
899 char *directory_name;
900 int saw_fun;
901 bfd_boolean saw_line, saw_func;
903 *pfound = FALSE;
904 *pfilename = bfd_get_filename (abfd);
905 *pfnname = NULL;
906 *pline = 0;
908 /* Stabs entries use a 12 byte format:
909 4 byte string table index
910 1 byte stab type
911 1 byte stab other field
912 2 byte stab desc field
913 4 byte stab value
914 FIXME: This will have to change for a 64 bit object format.
916 The stabs symbols are divided into compilation units. For the
917 first entry in each unit, the type of 0, the value is the length
918 of the string table for this unit, and the desc field is the
919 number of stabs symbols for this unit. */
921 #define STRDXOFF (0)
922 #define TYPEOFF (4)
923 #define OTHEROFF (5)
924 #define DESCOFF (6)
925 #define VALOFF (8)
926 #define STABSIZE (12)
928 info = *pinfo;
929 if (info != NULL)
931 if (info->stabsec == NULL || info->strsec == NULL)
933 /* No stabs debugging information. */
934 return TRUE;
937 stabsize = info->stabsec->_raw_size;
938 strsize = info->strsec->_raw_size;
940 else
942 long reloc_size, reloc_count;
943 arelent **reloc_vector;
944 int i;
945 char *name;
946 char *function_name;
947 bfd_size_type amt = sizeof *info;
949 info = bfd_zalloc (abfd, amt);
950 if (info == NULL)
951 return FALSE;
953 /* FIXME: When using the linker --split-by-file or
954 --split-by-reloc options, it is possible for the .stab and
955 .stabstr sections to be split. We should handle that. */
957 info->stabsec = bfd_get_section_by_name (abfd, ".stab");
958 info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
960 if (info->stabsec == NULL || info->strsec == NULL)
962 /* No stabs debugging information. Set *pinfo so that we
963 can return quickly in the info != NULL case above. */
964 *pinfo = info;
965 return TRUE;
968 stabsize = info->stabsec->_raw_size;
969 strsize = info->strsec->_raw_size;
971 info->stabs = bfd_alloc (abfd, stabsize);
972 info->strs = bfd_alloc (abfd, strsize);
973 if (info->stabs == NULL || info->strs == NULL)
974 return FALSE;
976 if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
977 (bfd_vma) 0, stabsize)
978 || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
979 (bfd_vma) 0, strsize))
980 return FALSE;
982 /* If this is a relocatable object file, we have to relocate
983 the entries in .stab. This should always be simple 32 bit
984 relocations against symbols defined in this object file, so
985 this should be no big deal. */
986 reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
987 if (reloc_size < 0)
988 return FALSE;
989 reloc_vector = bfd_malloc (reloc_size);
990 if (reloc_vector == NULL && reloc_size != 0)
991 return FALSE;
992 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
993 symbols);
994 if (reloc_count < 0)
996 if (reloc_vector != NULL)
997 free (reloc_vector);
998 return FALSE;
1000 if (reloc_count > 0)
1002 arelent **pr;
1004 for (pr = reloc_vector; *pr != NULL; pr++)
1006 arelent *r;
1007 unsigned long val;
1008 asymbol *sym;
1010 r = *pr;
1011 if (r->howto->rightshift != 0
1012 || r->howto->size != 2
1013 || r->howto->bitsize != 32
1014 || r->howto->pc_relative
1015 || r->howto->bitpos != 0
1016 || r->howto->dst_mask != 0xffffffff)
1018 (*_bfd_error_handler)
1019 (_("Unsupported .stab relocation"));
1020 bfd_set_error (bfd_error_invalid_operation);
1021 if (reloc_vector != NULL)
1022 free (reloc_vector);
1023 return FALSE;
1026 val = bfd_get_32 (abfd, info->stabs + r->address);
1027 val &= r->howto->src_mask;
1028 sym = *r->sym_ptr_ptr;
1029 val += sym->value + sym->section->vma + r->addend;
1030 bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1034 if (reloc_vector != NULL)
1035 free (reloc_vector);
1037 /* First time through this function, build a table matching
1038 function VM addresses to stabs, then sort based on starting
1039 VM address. Do this in two passes: once to count how many
1040 table entries we'll need, and a second to actually build the
1041 table. */
1043 info->indextablesize = 0;
1044 saw_fun = 1;
1045 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1047 if (stab[TYPEOFF] == (bfd_byte) N_SO)
1049 /* N_SO with null name indicates EOF */
1050 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1051 continue;
1053 /* if we did not see a function def, leave space for one. */
1054 if (saw_fun == 0)
1055 ++info->indextablesize;
1057 saw_fun = 0;
1059 /* two N_SO's in a row is a filename and directory. Skip */
1060 if (stab + STABSIZE < info->stabs + stabsize
1061 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1063 stab += STABSIZE;
1066 else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1068 saw_fun = 1;
1069 ++info->indextablesize;
1073 if (saw_fun == 0)
1074 ++info->indextablesize;
1076 if (info->indextablesize == 0)
1077 return TRUE;
1078 ++info->indextablesize;
1080 amt = info->indextablesize;
1081 amt *= sizeof (struct indexentry);
1082 info->indextable = bfd_alloc (abfd, amt);
1083 if (info->indextable == NULL)
1084 return FALSE;
1086 file_name = NULL;
1087 directory_name = NULL;
1088 saw_fun = 1;
1090 for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1091 i < info->indextablesize && stab < info->stabs + stabsize;
1092 stab += STABSIZE)
1094 switch (stab[TYPEOFF])
1096 case 0:
1097 /* This is the first entry in a compilation unit. */
1098 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1099 break;
1100 str += stroff;
1101 stroff = bfd_get_32 (abfd, stab + VALOFF);
1102 break;
1104 case N_SO:
1105 /* The main file name. */
1107 /* The following code creates a new indextable entry with
1108 a NULL function name if there were no N_FUNs in a file.
1109 Note that a N_SO without a file name is an EOF and
1110 there could be 2 N_SO following it with the new filename
1111 and directory. */
1112 if (saw_fun == 0)
1114 info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1115 info->indextable[i].stab = last_stab;
1116 info->indextable[i].str = str;
1117 info->indextable[i].directory_name = directory_name;
1118 info->indextable[i].file_name = file_name;
1119 info->indextable[i].function_name = NULL;
1120 ++i;
1122 saw_fun = 0;
1124 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1125 if (*file_name == '\0')
1127 directory_name = NULL;
1128 file_name = NULL;
1129 saw_fun = 1;
1131 else
1133 last_stab = stab;
1134 if (stab + STABSIZE >= info->stabs + stabsize
1135 || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1137 directory_name = NULL;
1139 else
1141 /* Two consecutive N_SOs are a directory and a
1142 file name. */
1143 stab += STABSIZE;
1144 directory_name = file_name;
1145 file_name = ((char *) str
1146 + bfd_get_32 (abfd, stab + STRDXOFF));
1149 break;
1151 case N_SOL:
1152 /* The name of an include file. */
1153 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1154 break;
1156 case N_FUN:
1157 /* A function name. */
1158 saw_fun = 1;
1159 name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1161 if (*name == '\0')
1162 name = NULL;
1164 function_name = name;
1166 if (name == NULL)
1167 continue;
1169 info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1170 info->indextable[i].stab = stab;
1171 info->indextable[i].str = str;
1172 info->indextable[i].directory_name = directory_name;
1173 info->indextable[i].file_name = file_name;
1174 info->indextable[i].function_name = function_name;
1175 ++i;
1176 break;
1180 if (saw_fun == 0)
1182 info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1183 info->indextable[i].stab = last_stab;
1184 info->indextable[i].str = str;
1185 info->indextable[i].directory_name = directory_name;
1186 info->indextable[i].file_name = file_name;
1187 info->indextable[i].function_name = NULL;
1188 ++i;
1191 info->indextable[i].val = (bfd_vma) -1;
1192 info->indextable[i].stab = info->stabs + stabsize;
1193 info->indextable[i].str = str;
1194 info->indextable[i].directory_name = NULL;
1195 info->indextable[i].file_name = NULL;
1196 info->indextable[i].function_name = NULL;
1197 ++i;
1199 info->indextablesize = i;
1200 qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1201 cmpindexentry);
1203 *pinfo = info;
1206 /* We are passed a section relative offset. The offsets in the
1207 stabs information are absolute. */
1208 offset += bfd_get_section_vma (abfd, section);
1210 #ifdef ENABLE_CACHING
1211 if (info->cached_indexentry != NULL
1212 && offset >= info->cached_offset
1213 && offset < (info->cached_indexentry + 1)->val)
1215 stab = info->cached_stab;
1216 indexentry = info->cached_indexentry;
1217 file_name = info->cached_file_name;
1219 else
1220 #endif
1222 long low, high;
1223 long mid = -1;
1225 /* Cache non-existent or invalid. Do binary search on
1226 indextable. */
1227 indexentry = NULL;
1229 low = 0;
1230 high = info->indextablesize - 1;
1231 while (low != high)
1233 mid = (high + low) / 2;
1234 if (offset >= info->indextable[mid].val
1235 && offset < info->indextable[mid + 1].val)
1237 indexentry = &info->indextable[mid];
1238 break;
1241 if (info->indextable[mid].val > offset)
1242 high = mid;
1243 else
1244 low = mid + 1;
1247 if (indexentry == NULL)
1248 return TRUE;
1250 stab = indexentry->stab + STABSIZE;
1251 file_name = indexentry->file_name;
1254 directory_name = indexentry->directory_name;
1255 str = indexentry->str;
1257 saw_line = FALSE;
1258 saw_func = FALSE;
1259 for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1261 bfd_boolean done;
1262 bfd_vma val;
1264 done = FALSE;
1266 switch (stab[TYPEOFF])
1268 case N_SOL:
1269 /* The name of an include file. */
1270 val = bfd_get_32 (abfd, stab + VALOFF);
1271 if (val <= offset)
1273 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1274 *pline = 0;
1276 break;
1278 case N_SLINE:
1279 case N_DSLINE:
1280 case N_BSLINE:
1281 /* A line number. If the function was specified, then the value
1282 is relative to the start of the function. Otherwise, the
1283 value is an absolute address. */
1284 val = ((indexentry->function_name ? indexentry->val : 0)
1285 + bfd_get_32 (abfd, stab + VALOFF));
1286 /* If this line starts before our desired offset, or if it's
1287 the first line we've been able to find, use it. The
1288 !saw_line check works around a bug in GCC 2.95.3, which emits
1289 the first N_SLINE late. */
1290 if (!saw_line || val <= offset)
1292 *pline = bfd_get_16 (abfd, stab + DESCOFF);
1294 #ifdef ENABLE_CACHING
1295 info->cached_stab = stab;
1296 info->cached_offset = val;
1297 info->cached_file_name = file_name;
1298 info->cached_indexentry = indexentry;
1299 #endif
1301 if (val > offset)
1302 done = TRUE;
1303 saw_line = TRUE;
1304 break;
1306 case N_FUN:
1307 case N_SO:
1308 if (saw_func || saw_line)
1309 done = TRUE;
1310 saw_func = TRUE;
1311 break;
1314 if (done)
1315 break;
1318 *pfound = TRUE;
1320 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1321 || directory_name == NULL)
1322 *pfilename = file_name;
1323 else
1325 size_t dirlen;
1327 dirlen = strlen (directory_name);
1328 if (info->filename == NULL
1329 || strncmp (info->filename, directory_name, dirlen) != 0
1330 || strcmp (info->filename + dirlen, file_name) != 0)
1332 size_t len;
1334 if (info->filename != NULL)
1335 free (info->filename);
1336 len = strlen (file_name) + 1;
1337 info->filename = bfd_malloc (dirlen + len);
1338 if (info->filename == NULL)
1339 return FALSE;
1340 memcpy (info->filename, directory_name, dirlen);
1341 memcpy (info->filename + dirlen, file_name, len);
1344 *pfilename = info->filename;
1347 if (indexentry->function_name != NULL)
1349 char *s;
1351 /* This will typically be something like main:F(0,1), so we want
1352 to clobber the colon. It's OK to change the name, since the
1353 string is in our own local storage anyhow. */
1354 s = strchr (indexentry->function_name, ':');
1355 if (s != NULL)
1356 *s = '\0';
1358 *pfnname = indexentry->function_name;
1361 return TRUE;