1 /* Generic symbol-table support for the BFD library.
2 Copyright (C) 1990-2018 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 BFD tries to maintain as much symbol information as it can when
27 it moves information from file to file. BFD passes information
28 to applications though the <<asymbol>> structure. When the
29 application requests the symbol table, BFD reads the table in
30 the native form and translates parts of it into the internal
31 format. To maintain more than the information passed to
32 applications, some targets keep some information ``behind the
33 scenes'' in a structure only the particular back end knows
34 about. For example, the coff back end keeps the original
35 symbol table structure as well as the canonical structure when
36 a BFD is read in. On output, the coff back end can reconstruct
37 the output symbol table so that no information is lost, even
38 information unique to coff which BFD doesn't know or
39 understand. If a coff symbol table were read, but were written
40 through an a.out back end, all the coff specific information
41 would be lost. The symbol table of a BFD
42 is not necessarily read in until a canonicalize request is
43 made. Then the BFD back end fills in a table provided by the
44 application with pointers to the canonical information. To
45 output symbols, the application provides BFD with a table of
46 pointers to pointers to <<asymbol>>s. This allows applications
47 like the linker to output a symbol as it was read, since the ``behind
48 the scenes'' information will be still available.
54 @* symbol handling functions::
58 Reading Symbols, Writing Symbols, Symbols, Symbols
62 There are two stages to reading a symbol table from a BFD:
63 allocating storage, and the actual reading process. This is an
64 excerpt from an application which reads the symbol table:
66 | long storage_needed;
67 | asymbol **symbol_table;
68 | long number_of_symbols;
71 | storage_needed = bfd_get_symtab_upper_bound (abfd);
73 | if (storage_needed < 0)
76 | if (storage_needed == 0)
79 | symbol_table = xmalloc (storage_needed);
82 | bfd_canonicalize_symtab (abfd, symbol_table);
84 | if (number_of_symbols < 0)
87 | for (i = 0; i < number_of_symbols; i++)
88 | process_symbol (symbol_table[i]);
90 All storage for the symbols themselves is in an objalloc
91 connected to the BFD; it is freed when the BFD is closed.
94 Writing Symbols, Mini Symbols, Reading Symbols, Symbols
98 Writing of a symbol table is automatic when a BFD open for
99 writing is closed. The application attaches a vector of
100 pointers to pointers to symbols to the BFD being written, and
101 fills in the symbol count. The close and cleanup code reads
102 through the table provided and performs all the necessary
103 operations. The BFD output code must always be provided with an
104 ``owned'' symbol: one which has come from another BFD, or one
105 which has been created using <<bfd_make_empty_symbol>>. Here is an
106 example showing the creation of a symbol table with only one element:
108 | #include "sysdep.h"
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;
127 | bfd_set_symtab (abfd, ptrs, 1);
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
143 Mini Symbols, typedef asymbol, Writing Symbols, 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.
169 typedef asymbol, symbol handling functions, Mini Symbols, Symbols
176 An <<asymbol>> has the form:
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
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. *}
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. *}
206 . {* Attributes of a symbol. *}
207 .#define BSF_NO_FLAGS 0
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 (1 << 0)
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 (1 << 1)
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_UNDEFINED>> or <<BSF_GLOBAL>>. *}
224 . {* The symbol is a debugging record. The value has an arbitrary
225 . meaning, unless BSF_DEBUGGING_RELOC is also set. *}
226 .#define BSF_DEBUGGING (1 << 2)
228 . {* The symbol denotes a function entry point. Used in ELF,
229 . perhaps others someday. *}
230 .#define BSF_FUNCTION (1 << 3)
232 . {* Used by the linker. *}
233 .#define BSF_KEEP (1 << 5)
235 . {* An ELF common symbol. *}
236 .#define BSF_ELF_COMMON (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
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
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
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)
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. *}
332 #include "safe-ctype.h"
334 #include "aout/stab_gnu.h"
339 symbol handling functions, , typedef asymbol, Symbols
341 Symbol handling functions
346 bfd_get_symtab_upper_bound
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))
364 bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
367 Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
368 a compiler generated local label, else return FALSE.
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)
379 if (sym->name == NULL)
381 return bfd_is_local_label_name (abfd, sym->name);
386 bfd_is_local_label_name
389 bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
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
397 .#define bfd_is_local_label_name(abfd, name) \
398 . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
404 bfd_is_target_special_symbol
407 bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
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))
421 bfd_canonicalize_symtab
424 Read the symbols from the BFD @var{abfd}, and fills in
425 the vector @var{location} with pointers to the symbols and
427 Return the actual number of symbol pointers, not
430 .#define bfd_canonicalize_symtab(abfd, location) \
431 . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
440 bfd_boolean bfd_set_symtab
441 (bfd *abfd, asymbol **location, unsigned int count);
444 Arrange that when the output BFD @var{abfd} is closed,
445 the table @var{location} of @var{count} pointers to symbols
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);
458 bfd_get_outsymbols (abfd) = location;
459 bfd_get_symcount (abfd) = symcount;
465 bfd_print_symbol_vandf
468 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
471 Print the value and flags of the @var{symbol} supplied to the
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);
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
489 fprintf (file, " %c%c%c%c%c%c%c",
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)
503 : ((type & BSF_OBJECT) ? 'O' : ' '))));
508 bfd_make_empty_symbol
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))
526 _bfd_generic_make_empty_symbol
529 asymbol *_bfd_generic_make_empty_symbol (bfd *);
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
539 _bfd_generic_make_empty_symbol (bfd *abfd)
541 bfd_size_type amt = sizeof (asymbol);
542 asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
544 new_symbol->the_bfd = abfd;
550 bfd_make_debug_symbol
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
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[] =
574 {"code", 't'}, /* MRI .text */
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. */
590 {"vars", 'd'}, /* MRI .data */
591 {"zerovars", 'b'}, /* MRI .bss */
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 */
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)))
613 /* Return the single-character symbol type corresponding to section
614 SECTION, or '?' for an unknown section. This uses section flags to
617 FIXME These types are unhandled: c, i, e, p. If we handled these also,
618 we could perhaps obsolete coff_section_type. */
621 decode_section_type (const struct bfd_section *section)
623 if (section->flags & SEC_CODE)
625 if (section->flags & SEC_DATA)
627 if (section->flags & SEC_READONLY)
629 else if (section->flags & SEC_SMALL_DATA)
634 if ((section->flags & SEC_HAS_CONTENTS) == 0)
636 if (section->flags & SEC_SMALL_DATA)
641 if (section->flags & SEC_DEBUGGING)
643 if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
654 Return a character corresponding to the symbol
655 class of @var{symbol}, or '?' for an unknown class.
658 int bfd_decode_symclass (asymbol *symbol);
661 bfd_decode_symclass (asymbol *symbol)
665 if (symbol->section && bfd_is_com_section (symbol->section))
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)
681 if (bfd_is_ind_section (symbol->section))
683 if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION)
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)
694 if (symbol->flags & BSF_GNU_UNIQUE)
696 if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
699 if (bfd_is_abs_section (symbol->section))
701 else if (symbol->section)
703 c = coff_section_type (symbol->section->name);
705 c = decode_section_type (symbol->section);
709 if (symbol->flags & BSF_GLOBAL)
713 /* We don't have to handle these cases just yet, but we will soon:
725 bfd_is_undefined_symclass
728 Returns non-zero if the class symbol returned by
729 bfd_decode_symclass represents an undefined symbol.
730 Returns zero otherwise.
733 bfd_boolean bfd_is_undefined_symclass (int symclass);
737 bfd_is_undefined_symclass (int symclass)
739 return symclass == 'U' || symclass == 'w' || symclass == 'v';
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.
752 void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
756 bfd_symbol_info (asymbol *symbol, symbol_info *ret)
758 ret->type = bfd_decode_symclass (symbol);
760 if (bfd_is_undefined_symclass (ret->type))
763 ret->value = symbol->value + symbol->section->vma;
765 ret->name = symbol->name;
770 bfd_copy_private_symbol_data
773 bfd_boolean bfd_copy_private_symbol_data
774 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
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
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. */
796 _bfd_generic_read_minisymbols (bfd *abfd,
802 asymbol **syms = NULL;
806 storage = bfd_get_dynamic_symtab_upper_bound (abfd);
808 storage = bfd_get_symtab_upper_bound (abfd);
814 syms = (asymbol **) bfd_malloc (storage);
819 symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
821 symcount = bfd_canonicalize_symtab (abfd, syms);
826 *sizep = sizeof (asymbol *);
831 bfd_set_error (bfd_error_no_symbols);
837 /* The generic version of the function which converts a minisymbol to
838 an asymbol. We don't worry about the sym argument we are passed;
839 we just return the asymbol the minisymbol points to. */
842 _bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
843 bfd_boolean dynamic ATTRIBUTE_UNUSED,
845 asymbol *sym ATTRIBUTE_UNUSED)
847 return *(asymbol **) minisym;
850 /* Look through stabs debugging information in .stab and .stabstr
851 sections to find the source file and line closest to a desired
852 location. This is used by COFF and ELF targets. It sets *pfound
853 to TRUE if it finds some information. The *pinfo field is used to
854 pass cached information in and out of this routine; this first time
855 the routine is called for a BFD, *pinfo should be NULL. The value
856 placed in *pinfo should be saved with the BFD, and passed back each
857 time this function is called. */
859 /* We use a cache by default. */
861 #define ENABLE_CACHING
863 /* We keep an array of indexentry structures to record where in the
864 stabs section we should look to find line number information for a
865 particular address. */
872 char *directory_name;
877 /* Compare two indexentry structures. This is called via qsort. */
880 cmpindexentry (const void *a, const void *b)
882 const struct indexentry *contestantA = (const struct indexentry *) a;
883 const struct indexentry *contestantB = (const struct indexentry *) b;
885 if (contestantA->val < contestantB->val)
887 else if (contestantA->val > contestantB->val)
893 /* A pointer to this structure is stored in *pinfo. */
895 struct stab_find_info
897 /* The .stab section. */
899 /* The .stabstr section. */
901 /* The contents of the .stab section. */
903 /* The contents of the .stabstr section. */
906 /* A table that indexes stabs by memory address. */
907 struct indexentry *indextable;
908 /* The number of entries in indextable. */
911 #ifdef ENABLE_CACHING
912 /* Cached values to restart quickly. */
913 struct indexentry *cached_indexentry;
914 bfd_vma cached_offset;
915 bfd_byte *cached_stab;
916 char *cached_file_name;
919 /* Saved ptr to malloc'ed filename. */
924 _bfd_stab_section_find_nearest_line (bfd *abfd,
929 const char **pfilename,
930 const char **pfnname,
934 struct stab_find_info *info;
935 bfd_size_type stabsize, strsize;
936 bfd_byte *stab, *str;
937 bfd_byte *nul_fun, *nul_str;
938 bfd_size_type stroff;
939 struct indexentry *indexentry;
941 char *directory_name;
942 bfd_boolean saw_line, saw_func;
945 *pfilename = bfd_get_filename (abfd);
949 /* Stabs entries use a 12 byte format:
950 4 byte string table index
952 1 byte stab other field
953 2 byte stab desc field
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. */
967 #define STABSIZE (12)
969 info = (struct stab_find_info *) *pinfo;
972 if (info->stabsec == NULL || info->strsec == NULL)
974 /* No stabs debugging information. */
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);
987 long reloc_size, reloc_count;
988 arelent **reloc_vector;
991 bfd_size_type amt = sizeof *info;
993 info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
997 /* FIXME: When using the linker --split-by-file or
998 --split-by-reloc options, it is possible for the .stab and
999 .stabstr sections to be split. We should handle that. */
1001 info->stabsec = bfd_get_section_by_name (abfd, ".stab");
1002 info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
1004 if (info->stabsec == NULL || info->strsec == NULL)
1006 /* Try SOM section names. */
1007 info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
1008 info->strsec = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
1010 if (info->stabsec == NULL || info->strsec == NULL)
1012 /* No stabs debugging information. Set *pinfo so that we
1013 can return quickly in the info != NULL case above. */
1019 stabsize = (info->stabsec->rawsize
1020 ? info->stabsec->rawsize
1021 : info->stabsec->size);
1022 stabsize = (stabsize / STABSIZE) * STABSIZE;
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)
1032 if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1034 || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
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);
1045 reloc_vector = (arelent **) bfd_malloc (reloc_size);
1046 if (reloc_vector == NULL && reloc_size != 0)
1048 reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1050 if (reloc_count < 0)
1052 if (reloc_vector != NULL)
1053 free (reloc_vector);
1056 if (reloc_count > 0)
1060 for (pr = reloc_vector; *pr != NULL; pr++)
1067 /* Ignore R_*_NONE relocs. */
1068 if (r->howto->dst_mask == 0)
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)
1079 (_("Unsupported .stab relocation"));
1080 bfd_set_error (bfd_error_invalid_operation);
1081 if (reloc_vector != NULL)
1082 free (reloc_vector);
1086 val = bfd_get_32 (abfd, info->stabs
1087 + r->address * bfd_octets_per_byte (abfd));
1088 val &= r->howto->src_mask;
1089 sym = *r->sym_ptr_ptr;
1090 val += sym->value + sym->section->vma + r->addend;
1091 bfd_put_32 (abfd, (bfd_vma) val, info->stabs
1092 + r->address * bfd_octets_per_byte (abfd));
1096 if (reloc_vector != NULL)
1097 free (reloc_vector);
1099 /* First time through this function, build a table matching
1100 function VM addresses to stabs, then sort based on starting
1101 VM address. Do this in two passes: once to count how many
1102 table entries we'll need, and a second to actually build the
1105 info->indextablesize = 0;
1107 for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1109 if (stab[TYPEOFF] == (bfd_byte) N_SO)
1111 /* if we did not see a function def, leave space for one. */
1112 if (nul_fun != NULL)
1113 ++info->indextablesize;
1115 /* N_SO with null name indicates EOF */
1116 if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1122 /* two N_SO's in a row is a filename and directory. Skip */
1123 if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1124 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1128 else if (stab[TYPEOFF] == (bfd_byte) N_FUN
1129 && bfd_get_32 (abfd, stab + STRDXOFF) != 0)
1132 ++info->indextablesize;
1136 if (nul_fun != NULL)
1137 ++info->indextablesize;
1139 if (info->indextablesize == 0)
1141 ++info->indextablesize;
1143 amt = info->indextablesize;
1144 amt *= sizeof (struct indexentry);
1145 info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
1146 if (info->indextable == NULL)
1150 directory_name = NULL;
1154 for (i = 0, stab = info->stabs, nul_str = str = info->strs;
1155 i < info->indextablesize && stab < info->stabs + stabsize;
1158 switch (stab[TYPEOFF])
1161 /* This is the first entry in a compilation unit. */
1162 if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1165 stroff = bfd_get_32 (abfd, stab + VALOFF);
1169 /* The main file name. */
1171 /* The following code creates a new indextable entry with
1172 a NULL function name if there were no N_FUNs in a file.
1173 Note that a N_SO without a file name is an EOF and
1174 there could be 2 N_SO following it with the new filename
1176 if (nul_fun != NULL)
1178 info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1179 info->indextable[i].stab = nul_fun;
1180 info->indextable[i].str = nul_str;
1181 info->indextable[i].directory_name = directory_name;
1182 info->indextable[i].file_name = file_name;
1183 info->indextable[i].function_name = NULL;
1187 directory_name = NULL;
1188 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1189 if (file_name == (char *) str)
1198 if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
1200 if (stab + STABSIZE + TYPEOFF < info->stabs + stabsize
1201 && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1203 /* Two consecutive N_SOs are a directory and a
1206 directory_name = file_name;
1207 file_name = ((char *) str
1208 + bfd_get_32 (abfd, stab + STRDXOFF));
1209 if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
1216 /* The name of an include file. */
1217 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1218 /* PR 17512: file: 0c680a1f. */
1219 /* PR 17512: file: 5da8aec4. */
1220 if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
1225 /* A function name. */
1226 function_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1227 if (function_name == (char *) str)
1229 if (function_name >= (char *) info->strs + strsize)
1230 function_name = NULL;
1233 info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1234 info->indextable[i].stab = stab;
1235 info->indextable[i].str = str;
1236 info->indextable[i].directory_name = directory_name;
1237 info->indextable[i].file_name = file_name;
1238 info->indextable[i].function_name = function_name;
1244 if (nul_fun != NULL)
1246 info->indextable[i].val = bfd_get_32 (abfd, nul_fun + VALOFF);
1247 info->indextable[i].stab = nul_fun;
1248 info->indextable[i].str = nul_str;
1249 info->indextable[i].directory_name = directory_name;
1250 info->indextable[i].file_name = file_name;
1251 info->indextable[i].function_name = NULL;
1255 info->indextable[i].val = (bfd_vma) -1;
1256 info->indextable[i].stab = info->stabs + stabsize;
1257 info->indextable[i].str = str;
1258 info->indextable[i].directory_name = NULL;
1259 info->indextable[i].file_name = NULL;
1260 info->indextable[i].function_name = NULL;
1263 info->indextablesize = i;
1264 qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1270 /* We are passed a section relative offset. The offsets in the
1271 stabs information are absolute. */
1272 offset += bfd_get_section_vma (abfd, section);
1274 #ifdef ENABLE_CACHING
1275 if (info->cached_indexentry != NULL
1276 && offset >= info->cached_offset
1277 && offset < (info->cached_indexentry + 1)->val)
1279 stab = info->cached_stab;
1280 indexentry = info->cached_indexentry;
1281 file_name = info->cached_file_name;
1289 /* Cache non-existent or invalid. Do binary search on
1294 high = info->indextablesize - 1;
1297 mid = (high + low) / 2;
1298 if (offset >= info->indextable[mid].val
1299 && offset < info->indextable[mid + 1].val)
1301 indexentry = &info->indextable[mid];
1305 if (info->indextable[mid].val > offset)
1311 if (indexentry == NULL)
1314 stab = indexentry->stab + STABSIZE;
1315 file_name = indexentry->file_name;
1318 directory_name = indexentry->directory_name;
1319 str = indexentry->str;
1323 for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1330 switch (stab[TYPEOFF])
1333 /* The name of an include file. */
1334 val = bfd_get_32 (abfd, stab + VALOFF);
1337 file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1338 if (file_name >= (char *) info->strs + strsize || file_name < (char *) str)
1347 /* A line number. If the function was specified, then the value
1348 is relative to the start of the function. Otherwise, the
1349 value is an absolute address. */
1350 val = ((indexentry->function_name ? indexentry->val : 0)
1351 + bfd_get_32 (abfd, stab + VALOFF));
1352 /* If this line starts before our desired offset, or if it's
1353 the first line we've been able to find, use it. The
1354 !saw_line check works around a bug in GCC 2.95.3, which emits
1355 the first N_SLINE late. */
1356 if (!saw_line || val <= offset)
1358 *pline = bfd_get_16 (abfd, stab + DESCOFF);
1360 #ifdef ENABLE_CACHING
1361 info->cached_stab = stab;
1362 info->cached_offset = val;
1363 info->cached_file_name = file_name;
1364 info->cached_indexentry = indexentry;
1374 if (saw_func || saw_line)
1386 if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1387 || directory_name == NULL)
1388 *pfilename = file_name;
1393 dirlen = strlen (directory_name);
1394 if (info->filename == NULL
1395 || filename_ncmp (info->filename, directory_name, dirlen) != 0
1396 || filename_cmp (info->filename + dirlen, file_name) != 0)
1400 /* Don't free info->filename here. objdump and other
1401 apps keep a copy of a previously returned file name
1403 len = strlen (file_name) + 1;
1404 info->filename = (char *) bfd_alloc (abfd, dirlen + len);
1405 if (info->filename == NULL)
1407 memcpy (info->filename, directory_name, dirlen);
1408 memcpy (info->filename + dirlen, file_name, len);
1411 *pfilename = info->filename;
1414 if (indexentry->function_name != NULL)
1418 /* This will typically be something like main:F(0,1), so we want
1419 to clobber the colon. It's OK to change the name, since the
1420 string is in our own local storage anyhow. */
1421 s = strchr (indexentry->function_name, ':');
1425 *pfnname = indexentry->function_name;
1432 _bfd_nosymbols_canonicalize_symtab (bfd *abfd ATTRIBUTE_UNUSED,
1433 asymbol **location ATTRIBUTE_UNUSED)
1439 _bfd_nosymbols_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
1440 void *afile ATTRIBUTE_UNUSED,
1441 asymbol *symbol ATTRIBUTE_UNUSED,
1442 bfd_print_symbol_type how ATTRIBUTE_UNUSED)
1447 _bfd_nosymbols_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1448 asymbol *sym ATTRIBUTE_UNUSED,
1449 symbol_info *ret ATTRIBUTE_UNUSED)
1454 _bfd_nosymbols_get_symbol_version_string (bfd *abfd,
1455 asymbol *symbol ATTRIBUTE_UNUSED,
1456 bfd_boolean *hidden ATTRIBUTE_UNUSED)
1458 return (const char *) _bfd_ptr_bfd_null_error (abfd);
1462 _bfd_nosymbols_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1463 const char *name ATTRIBUTE_UNUSED)
1469 _bfd_nosymbols_get_lineno (bfd *abfd, asymbol *sym ATTRIBUTE_UNUSED)
1471 return (alent *) _bfd_ptr_bfd_null_error (abfd);
1475 _bfd_nosymbols_find_nearest_line
1477 asymbol **symbols ATTRIBUTE_UNUSED,
1478 asection *section ATTRIBUTE_UNUSED,
1479 bfd_vma offset ATTRIBUTE_UNUSED,
1480 const char **filename_ptr ATTRIBUTE_UNUSED,
1481 const char **functionname_ptr ATTRIBUTE_UNUSED,
1482 unsigned int *line_ptr ATTRIBUTE_UNUSED,
1483 unsigned int *discriminator_ptr ATTRIBUTE_UNUSED)
1485 return _bfd_bool_bfd_false_error (abfd);
1489 _bfd_nosymbols_find_line (bfd *abfd,
1490 asymbol **symbols ATTRIBUTE_UNUSED,
1491 asymbol *symbol ATTRIBUTE_UNUSED,
1492 const char **filename_ptr ATTRIBUTE_UNUSED,
1493 unsigned int *line_ptr ATTRIBUTE_UNUSED)
1495 return _bfd_bool_bfd_false_error (abfd);
1499 _bfd_nosymbols_find_inliner_info
1501 const char **filename_ptr ATTRIBUTE_UNUSED,
1502 const char **functionname_ptr ATTRIBUTE_UNUSED,
1503 unsigned int *line_ptr ATTRIBUTE_UNUSED)
1505 return _bfd_bool_bfd_false_error (abfd);
1509 _bfd_nosymbols_bfd_make_debug_symbol (bfd *abfd,
1510 void *ptr ATTRIBUTE_UNUSED,
1511 unsigned long sz ATTRIBUTE_UNUSED)
1513 return (asymbol *) _bfd_ptr_bfd_null_error (abfd);
1517 _bfd_nosymbols_read_minisymbols (bfd *abfd,
1518 bfd_boolean dynamic ATTRIBUTE_UNUSED,
1519 void **minisymsp ATTRIBUTE_UNUSED,
1520 unsigned int *sizep ATTRIBUTE_UNUSED)
1522 return _bfd_long_bfd_n1_error (abfd);
1526 _bfd_nosymbols_minisymbol_to_symbol (bfd *abfd,
1527 bfd_boolean dynamic ATTRIBUTE_UNUSED,
1528 const void *minisym ATTRIBUTE_UNUSED,
1529 asymbol *sym ATTRIBUTE_UNUSED)
1531 return (asymbol *) _bfd_ptr_bfd_null_error (abfd);
1535 _bfd_nodynamic_get_synthetic_symtab (bfd *abfd,
1536 long symcount ATTRIBUTE_UNUSED,
1537 asymbol **syms ATTRIBUTE_UNUSED,
1538 long dynsymcount ATTRIBUTE_UNUSED,
1539 asymbol **dynsyms ATTRIBUTE_UNUSED,
1540 asymbol **ret ATTRIBUTE_UNUSED)
1542 return _bfd_long_bfd_n1_error (abfd);