1 /* Generic symbol-table support for the BFD library.
2 Copyright (C) 1990-2023 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)
310 . {* This section symbol should be included in the symbol table. *}
311 .#define BSF_SECTION_SYM_USED (1 << 24)
315 . {* A pointer to the section to which this symbol is
316 . relative. This will always be non NULL, there are special
317 . sections for undefined and absolute symbols. *}
318 . struct bfd_section *section;
320 . {* Back end special data. *}
335 #include "safe-ctype.h"
337 #include "aout/stab_gnu.h"
342 symbol handling functions, , typedef asymbol, Symbols
344 Symbol handling functions
349 bfd_get_symtab_upper_bound
352 Return the number of bytes required to store a vector of pointers
353 to <<asymbols>> for all the symbols in the BFD @var{abfd},
354 including a terminal NULL pointer. If there are no symbols in
355 the BFD, then return 0. If an error occurs, return -1.
357 .#define bfd_get_symtab_upper_bound(abfd) \
358 . BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
367 bool bfd_is_local_label (bfd *abfd, asymbol *sym);
370 Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
371 a compiler generated local label, else return FALSE.
375 bfd_is_local_label (bfd
*abfd
, asymbol
*sym
)
377 /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
378 starts with '.' is local. This would accidentally catch section names
379 if we didn't reject them here. */
380 if ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_FILE
| BSF_SECTION_SYM
)) != 0)
382 if (sym
->name
== NULL
)
384 return bfd_is_local_label_name (abfd
, sym
->name
);
389 bfd_is_local_label_name
392 bool bfd_is_local_label_name (bfd *abfd, const char *name);
395 Return TRUE if a symbol with the name @var{name} in the BFD
396 @var{abfd} is a compiler generated local label, else return
397 FALSE. This just checks whether the name has the form of a
400 .#define bfd_is_local_label_name(abfd, name) \
401 . BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
407 bfd_is_target_special_symbol
410 bool bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
413 Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something
414 special to the particular target represented by the BFD. Such symbols
415 should normally not be mentioned to the user.
417 .#define bfd_is_target_special_symbol(abfd, sym) \
418 . BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
424 bfd_canonicalize_symtab
427 Read the symbols from the BFD @var{abfd}, and fills in
428 the vector @var{location} with pointers to the symbols and
430 Return the actual number of symbol pointers, not
433 .#define bfd_canonicalize_symtab(abfd, location) \
434 . BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
444 (bfd *abfd, asymbol **location, unsigned int count);
447 Arrange that when the output BFD @var{abfd} is closed,
448 the table @var{location} of @var{count} pointers to symbols
453 bfd_set_symtab (bfd
*abfd
, asymbol
**location
, unsigned int symcount
)
455 if (abfd
->format
!= bfd_object
|| bfd_read_p (abfd
))
457 bfd_set_error (bfd_error_invalid_operation
);
461 abfd
->outsymbols
= location
;
462 abfd
->symcount
= symcount
;
468 bfd_print_symbol_vandf
471 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
474 Print the value and flags of the @var{symbol} supplied to the
478 bfd_print_symbol_vandf (bfd
*abfd
, void *arg
, asymbol
*symbol
)
480 FILE *file
= (FILE *) arg
;
482 flagword type
= symbol
->flags
;
484 if (symbol
->section
!= NULL
)
485 bfd_fprintf_vma (abfd
, file
, symbol
->value
+ symbol
->section
->vma
);
487 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
489 /* This presumes that a symbol can not be both BSF_DEBUGGING and
490 BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
492 fprintf (file
, " %c%c%c%c%c%c%c",
494 ? (type
& BSF_GLOBAL
) ? '!' : 'l'
495 : (type
& BSF_GLOBAL
) ? 'g'
496 : (type
& BSF_GNU_UNIQUE
) ? 'u' : ' '),
497 (type
& BSF_WEAK
) ? 'w' : ' ',
498 (type
& BSF_CONSTRUCTOR
) ? 'C' : ' ',
499 (type
& BSF_WARNING
) ? 'W' : ' ',
500 (type
& BSF_INDIRECT
) ? 'I' : (type
& BSF_GNU_INDIRECT_FUNCTION
) ? 'i' : ' ',
501 (type
& BSF_DEBUGGING
) ? 'd' : (type
& BSF_DYNAMIC
) ? 'D' : ' ',
502 ((type
& BSF_FUNCTION
)
506 : ((type
& BSF_OBJECT
) ? 'O' : ' '))));
511 bfd_make_empty_symbol
514 Create a new <<asymbol>> structure for the BFD @var{abfd}
515 and return a pointer to it.
517 This routine is necessary because each back end has private
518 information surrounding the <<asymbol>>. Building your own
519 <<asymbol>> and pointing to it will not create the private
520 information, and will cause problems later on.
522 .#define bfd_make_empty_symbol(abfd) \
523 . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
529 _bfd_generic_make_empty_symbol
532 asymbol *_bfd_generic_make_empty_symbol (bfd *);
535 Create a new <<asymbol>> structure for the BFD @var{abfd}
536 and return a pointer to it. Used by core file routines,
537 binary back-end and anywhere else where no private info
542 _bfd_generic_make_empty_symbol (bfd
*abfd
)
544 size_t amt
= sizeof (asymbol
);
545 asymbol
*new_symbol
= (asymbol
*) bfd_zalloc (abfd
, amt
);
547 new_symbol
->the_bfd
= abfd
;
553 bfd_make_debug_symbol
556 Create a new <<asymbol>> structure for the BFD @var{abfd},
557 to be used as a debugging symbol. Further details of its use have
558 yet to be worked out.
560 .#define bfd_make_debug_symbol(abfd,ptr,size) \
561 . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
565 struct section_to_type
571 /* Map special section names to POSIX/BSD single-character symbol types.
572 This table is probably incomplete. It is sorted for convenience of
573 adding entries. Since it is so short, a linear search is used. */
574 static const struct section_to_type stt
[] =
576 {".drectve", 'i'}, /* MSVC's .drective section */
577 {".edata", 'e'}, /* MSVC's .edata (export) section */
578 {".idata", 'i'}, /* MSVC's .idata (import) section */
579 {".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */
583 /* Return the single-character symbol type corresponding to
584 section S, or '?' for an unknown COFF section.
586 Check for leading strings which match, followed by a number, '.',
587 or '$' so .idata5 matches the .idata entry. */
590 coff_section_type (const char *s
)
592 const struct section_to_type
*t
;
594 for (t
= &stt
[0]; t
->section
; t
++)
596 size_t len
= strlen (t
->section
);
597 if (strncmp (s
, t
->section
, len
) == 0
598 && memchr (".$0123456789", s
[len
], 13) != 0)
605 /* Return the single-character symbol type corresponding to section
606 SECTION, or '?' for an unknown section. This uses section flags to
609 FIXME These types are unhandled: e, i, p. If we handled these also,
610 we could perhaps obsolete coff_section_type. */
613 decode_section_type (const struct bfd_section
*section
)
615 if (section
->flags
& SEC_CODE
)
617 if (section
->flags
& SEC_DATA
)
619 if (section
->flags
& SEC_READONLY
)
621 else if (section
->flags
& SEC_SMALL_DATA
)
626 if ((section
->flags
& SEC_HAS_CONTENTS
) == 0)
628 if (section
->flags
& SEC_SMALL_DATA
)
633 if (section
->flags
& SEC_DEBUGGING
)
635 if ((section
->flags
& SEC_HAS_CONTENTS
) && (section
->flags
& SEC_READONLY
))
646 int bfd_decode_symclass (asymbol *symbol);
649 Return a character corresponding to the symbol
650 class of @var{symbol}, or '?' for an unknown class.
653 bfd_decode_symclass (asymbol
*symbol
)
658 if (symbol
== NULL
|| symbol
->section
== NULL
)
661 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
663 if (symbol
->section
->flags
& SEC_SMALL_DATA
)
668 if (bfd_is_und_section (symbol
->section
))
670 if (symbol
->flags
& BSF_WEAK
)
672 /* If weak, determine if it's specifically an object
673 or non-object weak. */
674 if (symbol
->flags
& BSF_OBJECT
)
682 if (bfd_is_ind_section (symbol
->section
))
684 if (symbol
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
686 if (symbol
->flags
& BSF_WEAK
)
688 /* If weak, determine if it's specifically an object
689 or non-object weak. */
690 if (symbol
->flags
& BSF_OBJECT
)
695 if (symbol
->flags
& BSF_GNU_UNIQUE
)
697 if (!(symbol
->flags
& (BSF_GLOBAL
| BSF_LOCAL
)))
700 if (bfd_is_abs_section (symbol
->section
))
702 else if (symbol
->section
)
704 c
= coff_section_type (symbol
->section
->name
);
706 c
= decode_section_type (symbol
->section
);
710 if (symbol
->flags
& BSF_GLOBAL
)
714 /* We don't have to handle these cases just yet, but we will soon:
726 bfd_is_undefined_symclass
729 bool bfd_is_undefined_symclass (int symclass);
732 Returns non-zero if the class symbol returned by
733 bfd_decode_symclass represents an undefined symbol.
734 Returns zero otherwise.
738 bfd_is_undefined_symclass (int symclass
)
740 return symclass
== 'U' || symclass
== 'w' || symclass
== 'v';
748 void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
751 Fill in the basic info about symbol that nm needs.
752 Additional info may be added by the back-ends after
753 calling this function.
757 bfd_symbol_info (asymbol
*symbol
, symbol_info
*ret
)
759 ret
->type
= bfd_decode_symclass (symbol
);
761 if (bfd_is_undefined_symclass (ret
->type
))
764 ret
->value
= symbol
->value
+ symbol
->section
->vma
;
766 ret
->name
= symbol
->name
;
771 bfd_copy_private_symbol_data
774 bool bfd_copy_private_symbol_data
775 (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
778 Copy private symbol information from @var{isym} in the BFD
779 @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
780 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
783 o <<bfd_error_no_memory>> -
784 Not enough memory exists to create private data for @var{osec}.
786 .#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
787 . BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
788 . (ibfd, isymbol, obfd, osymbol))
792 /* The generic version of the function which returns mini symbols.
793 This is used when the backend does not provide a more efficient
794 version. It just uses BFD asymbol structures as mini symbols. */
797 _bfd_generic_read_minisymbols (bfd
*abfd
,
803 asymbol
**syms
= NULL
;
807 storage
= bfd_get_dynamic_symtab_upper_bound (abfd
);
809 storage
= bfd_get_symtab_upper_bound (abfd
);
815 syms
= (asymbol
**) bfd_malloc (storage
);
820 symcount
= bfd_canonicalize_dynamic_symtab (abfd
, syms
);
822 symcount
= bfd_canonicalize_symtab (abfd
, syms
);
827 /* We return 0 above when storage is 0. Exit in the same state
828 here, so as to not complicate callers with having to deal with
829 freeing memory for zero symcount. */
834 *sizep
= sizeof (asymbol
*);
839 bfd_set_error (bfd_error_no_symbols
);
844 /* The generic version of the function which converts a minisymbol to
845 an asymbol. We don't worry about the sym argument we are passed;
846 we just return the asymbol the minisymbol points to. */
849 _bfd_generic_minisymbol_to_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
850 bool dynamic ATTRIBUTE_UNUSED
,
852 asymbol
*sym ATTRIBUTE_UNUSED
)
854 return *(asymbol
**) minisym
;
857 /* Look through stabs debugging information in .stab and .stabstr
858 sections to find the source file and line closest to a desired
859 location. This is used by COFF and ELF targets. It sets *pfound
860 to TRUE if it finds some information. The *pinfo field is used to
861 pass cached information in and out of this routine; this first time
862 the routine is called for a BFD, *pinfo should be NULL. The value
863 placed in *pinfo should be saved with the BFD, and passed back each
864 time this function is called. */
866 /* We use a cache by default. */
868 #define ENABLE_CACHING
870 /* We keep an array of indexentry structures to record where in the
871 stabs section we should look to find line number information for a
872 particular address. */
879 char *directory_name
;
885 /* Compare two indexentry structures. This is called via qsort. */
888 cmpindexentry (const void *a
, const void *b
)
890 const struct indexentry
*contestantA
= (const struct indexentry
*) a
;
891 const struct indexentry
*contestantB
= (const struct indexentry
*) b
;
893 if (contestantA
->val
< contestantB
->val
)
895 if (contestantA
->val
> contestantB
->val
)
897 return contestantA
->idx
- contestantB
->idx
;
900 /* A pointer to this structure is stored in *pinfo. */
902 struct stab_find_info
904 /* The .stab section. */
906 /* The .stabstr section. */
908 /* The contents of the .stab section. */
910 /* The contents of the .stabstr section. */
913 /* A table that indexes stabs by memory address. */
914 struct indexentry
*indextable
;
915 /* The number of entries in indextable. */
918 #ifdef ENABLE_CACHING
919 /* Cached values to restart quickly. */
920 struct indexentry
*cached_indexentry
;
921 bfd_vma cached_offset
;
922 bfd_byte
*cached_stab
;
923 char *cached_file_name
;
926 /* Saved ptr to malloc'ed filename. */
931 _bfd_stab_section_find_nearest_line (bfd
*abfd
,
936 const char **pfilename
,
937 const char **pfnname
,
941 struct stab_find_info
*info
;
942 bfd_size_type stabsize
, strsize
;
943 bfd_byte
*stab
, *str
;
944 bfd_byte
*nul_fun
, *nul_str
;
945 bfd_size_type stroff
;
946 struct indexentry
*indexentry
;
948 char *directory_name
;
949 bool saw_line
, saw_func
;
952 *pfilename
= bfd_get_filename (abfd
);
956 /* Stabs entries use a 12 byte format:
957 4 byte string table index
959 1 byte stab other field
960 2 byte stab desc field
962 FIXME: This will have to change for a 64 bit object format.
964 The stabs symbols are divided into compilation units. For the
965 first entry in each unit, the type of 0, the value is the length
966 of the string table for this unit, and the desc field is the
967 number of stabs symbols for this unit. */
974 #define STABSIZE (12)
976 info
= (struct stab_find_info
*) *pinfo
;
979 if (info
->stabsec
== NULL
|| info
->strsec
== NULL
)
981 /* No usable stabs debugging information. */
985 stabsize
= (info
->stabsec
->rawsize
986 ? info
->stabsec
->rawsize
987 : info
->stabsec
->size
);
988 strsize
= (info
->strsec
->rawsize
989 ? info
->strsec
->rawsize
990 : info
->strsec
->size
);
994 long reloc_size
, reloc_count
;
995 arelent
**reloc_vector
;
998 bfd_size_type amt
= sizeof *info
;
1000 info
= (struct stab_find_info
*) bfd_zalloc (abfd
, amt
);
1005 /* FIXME: When using the linker --split-by-file or
1006 --split-by-reloc options, it is possible for the .stab and
1007 .stabstr sections to be split. We should handle that. */
1009 info
->stabsec
= bfd_get_section_by_name (abfd
, ".stab");
1010 info
->strsec
= bfd_get_section_by_name (abfd
, ".stabstr");
1012 if (info
->stabsec
== NULL
|| info
->strsec
== NULL
)
1014 /* Try SOM section names. */
1015 info
->stabsec
= bfd_get_section_by_name (abfd
, "$GDB_SYMBOLS$");
1016 info
->strsec
= bfd_get_section_by_name (abfd
, "$GDB_STRINGS$");
1018 if (info
->stabsec
== NULL
|| info
->strsec
== NULL
)
1022 if ((info
->stabsec
->flags
& SEC_HAS_CONTENTS
) == 0
1023 || (info
->strsec
->flags
& SEC_HAS_CONTENTS
) == 0)
1026 stabsize
= (info
->stabsec
->rawsize
1027 ? info
->stabsec
->rawsize
1028 : info
->stabsec
->size
);
1029 stabsize
= (stabsize
/ STABSIZE
) * STABSIZE
;
1030 strsize
= (info
->strsec
->rawsize
1031 ? info
->strsec
->rawsize
1032 : info
->strsec
->size
);
1034 if (stabsize
== 0 || strsize
== 0)
1037 if (!bfd_malloc_and_get_section (abfd
, info
->stabsec
, &info
->stabs
))
1039 if (!bfd_malloc_and_get_section (abfd
, info
->strsec
, &info
->strs
))
1042 /* Stab strings ought to be nul terminated. Ensure the last one
1043 is, to prevent running off the end of the buffer. */
1044 info
->strs
[strsize
- 1] = 0;
1046 /* If this is a relocatable object file, we have to relocate
1047 the entries in .stab. This should always be simple 32 bit
1048 relocations against symbols defined in this object file, so
1049 this should be no big deal. */
1050 reloc_size
= bfd_get_reloc_upper_bound (abfd
, info
->stabsec
);
1053 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
1054 if (reloc_vector
== NULL
&& reloc_size
!= 0)
1056 reloc_count
= bfd_canonicalize_reloc (abfd
, info
->stabsec
, reloc_vector
,
1058 if (reloc_count
< 0)
1061 free (reloc_vector
);
1069 info
->stabsec
= NULL
;
1072 if (reloc_count
> 0)
1076 for (pr
= reloc_vector
; *pr
!= NULL
; pr
++)
1081 bfd_size_type octets
;
1084 /* Ignore R_*_NONE relocs. */
1085 if (r
->howto
->dst_mask
== 0)
1088 octets
= r
->address
* bfd_octets_per_byte (abfd
, NULL
);
1089 if (r
->howto
->rightshift
!= 0
1090 || bfd_get_reloc_size (r
->howto
) != 4
1091 || r
->howto
->bitsize
!= 32
1092 || r
->howto
->pc_relative
1093 || r
->howto
->bitpos
!= 0
1094 || r
->howto
->dst_mask
!= 0xffffffff
1095 || octets
+ 4 > stabsize
)
1098 (_("unsupported .stab relocation"));
1099 bfd_set_error (bfd_error_invalid_operation
);
1103 val
= bfd_get_32 (abfd
, info
->stabs
+ octets
);
1104 val
&= r
->howto
->src_mask
;
1105 sym
= *r
->sym_ptr_ptr
;
1106 val
+= sym
->value
+ sym
->section
->vma
+ r
->addend
;
1107 bfd_put_32 (abfd
, (bfd_vma
) val
, info
->stabs
+ octets
);
1111 free (reloc_vector
);
1113 /* First time through this function, build a table matching
1114 function VM addresses to stabs, then sort based on starting
1115 VM address. Do this in two passes: once to count how many
1116 table entries we'll need, and a second to actually build the
1119 info
->indextablesize
= 0;
1121 for (stab
= info
->stabs
; stab
< info
->stabs
+ stabsize
; stab
+= STABSIZE
)
1123 if (stab
[TYPEOFF
] == (bfd_byte
) N_SO
)
1125 /* if we did not see a function def, leave space for one. */
1126 if (nul_fun
!= NULL
)
1127 ++info
->indextablesize
;
1129 /* N_SO with null name indicates EOF */
1130 if (bfd_get_32 (abfd
, stab
+ STRDXOFF
) == 0)
1136 /* two N_SO's in a row is a filename and directory. Skip */
1137 if (stab
+ STABSIZE
+ TYPEOFF
< info
->stabs
+ stabsize
1138 && *(stab
+ STABSIZE
+ TYPEOFF
) == (bfd_byte
) N_SO
)
1142 else if (stab
[TYPEOFF
] == (bfd_byte
) N_FUN
1143 && bfd_get_32 (abfd
, stab
+ STRDXOFF
) != 0)
1146 ++info
->indextablesize
;
1150 if (nul_fun
!= NULL
)
1151 ++info
->indextablesize
;
1153 if (info
->indextablesize
== 0)
1159 info
->stabsec
= NULL
;
1162 ++info
->indextablesize
;
1164 amt
= info
->indextablesize
;
1165 amt
*= sizeof (struct indexentry
);
1166 info
->indextable
= (struct indexentry
*) bfd_malloc (amt
);
1167 if (info
->indextable
== NULL
)
1171 directory_name
= NULL
;
1175 for (i
= 0, stab
= info
->stabs
, nul_str
= str
= info
->strs
;
1176 i
< info
->indextablesize
&& stab
< info
->stabs
+ stabsize
;
1179 switch (stab
[TYPEOFF
])
1182 /* This is the first entry in a compilation unit. */
1183 if ((bfd_size_type
) ((info
->strs
+ strsize
) - str
) < stroff
)
1186 stroff
= bfd_get_32 (abfd
, stab
+ VALOFF
);
1190 /* The main file name. */
1192 /* The following code creates a new indextable entry with
1193 a NULL function name if there were no N_FUNs in a file.
1194 Note that a N_SO without a file name is an EOF and
1195 there could be 2 N_SO following it with the new filename
1197 if (nul_fun
!= NULL
)
1199 info
->indextable
[i
].val
= bfd_get_32 (abfd
, nul_fun
+ VALOFF
);
1200 info
->indextable
[i
].stab
= nul_fun
;
1201 info
->indextable
[i
].str
= nul_str
;
1202 info
->indextable
[i
].directory_name
= directory_name
;
1203 info
->indextable
[i
].file_name
= file_name
;
1204 info
->indextable
[i
].function_name
= NULL
;
1205 info
->indextable
[i
].idx
= i
;
1209 directory_name
= NULL
;
1210 file_name
= (char *) str
+ bfd_get_32 (abfd
, stab
+ STRDXOFF
);
1211 if (file_name
== (char *) str
)
1220 if (file_name
>= (char *) info
->strs
+ strsize
1221 || file_name
< (char *) str
)
1223 if (stab
+ STABSIZE
+ TYPEOFF
< info
->stabs
+ stabsize
1224 && *(stab
+ STABSIZE
+ TYPEOFF
) == (bfd_byte
) N_SO
)
1226 /* Two consecutive N_SOs are a directory and a
1229 directory_name
= file_name
;
1230 file_name
= ((char *) str
1231 + bfd_get_32 (abfd
, stab
+ STRDXOFF
));
1232 if (file_name
>= (char *) info
->strs
+ strsize
1233 || file_name
< (char *) str
)
1240 /* The name of an include file. */
1241 file_name
= (char *) str
+ bfd_get_32 (abfd
, stab
+ STRDXOFF
);
1242 /* PR 17512: file: 0c680a1f. */
1243 /* PR 17512: file: 5da8aec4. */
1244 if (file_name
>= (char *) info
->strs
+ strsize
1245 || file_name
< (char *) str
)
1250 /* A function name. */
1251 function_name
= (char *) str
+ bfd_get_32 (abfd
, stab
+ STRDXOFF
);
1252 if (function_name
== (char *) str
)
1254 if (function_name
>= (char *) info
->strs
+ strsize
1255 || function_name
< (char *) str
)
1256 function_name
= NULL
;
1259 info
->indextable
[i
].val
= bfd_get_32 (abfd
, stab
+ VALOFF
);
1260 info
->indextable
[i
].stab
= stab
;
1261 info
->indextable
[i
].str
= str
;
1262 info
->indextable
[i
].directory_name
= directory_name
;
1263 info
->indextable
[i
].file_name
= file_name
;
1264 info
->indextable
[i
].function_name
= function_name
;
1265 info
->indextable
[i
].idx
= i
;
1271 if (nul_fun
!= NULL
)
1273 info
->indextable
[i
].val
= bfd_get_32 (abfd
, nul_fun
+ VALOFF
);
1274 info
->indextable
[i
].stab
= nul_fun
;
1275 info
->indextable
[i
].str
= nul_str
;
1276 info
->indextable
[i
].directory_name
= directory_name
;
1277 info
->indextable
[i
].file_name
= file_name
;
1278 info
->indextable
[i
].function_name
= NULL
;
1279 info
->indextable
[i
].idx
= i
;
1283 info
->indextable
[i
].val
= (bfd_vma
) -1;
1284 info
->indextable
[i
].stab
= info
->stabs
+ stabsize
;
1285 info
->indextable
[i
].str
= str
;
1286 info
->indextable
[i
].directory_name
= NULL
;
1287 info
->indextable
[i
].file_name
= NULL
;
1288 info
->indextable
[i
].function_name
= NULL
;
1289 info
->indextable
[i
].idx
= i
;
1292 info
->indextablesize
= i
;
1293 qsort (info
->indextable
, (size_t) i
, sizeof (struct indexentry
),
1297 /* We are passed a section relative offset. The offsets in the
1298 stabs information are absolute. */
1299 offset
+= bfd_section_vma (section
);
1301 #ifdef ENABLE_CACHING
1302 if (info
->cached_indexentry
!= NULL
1303 && offset
>= info
->cached_offset
1304 && offset
< (info
->cached_indexentry
+ 1)->val
)
1306 stab
= info
->cached_stab
;
1307 indexentry
= info
->cached_indexentry
;
1308 file_name
= info
->cached_file_name
;
1316 /* Cache non-existent or invalid. Do binary search on
1321 high
= info
->indextablesize
- 1;
1324 mid
= (high
+ low
) / 2;
1325 if (offset
>= info
->indextable
[mid
].val
1326 && offset
< info
->indextable
[mid
+ 1].val
)
1328 indexentry
= &info
->indextable
[mid
];
1332 if (info
->indextable
[mid
].val
> offset
)
1338 if (indexentry
== NULL
)
1341 stab
= indexentry
->stab
+ STABSIZE
;
1342 file_name
= indexentry
->file_name
;
1345 directory_name
= indexentry
->directory_name
;
1346 str
= indexentry
->str
;
1350 for (; stab
< (indexentry
+1)->stab
; stab
+= STABSIZE
)
1357 switch (stab
[TYPEOFF
])
1360 /* The name of an include file. */
1361 val
= bfd_get_32 (abfd
, stab
+ VALOFF
);
1364 file_name
= (char *) str
+ bfd_get_32 (abfd
, stab
+ STRDXOFF
);
1365 if (file_name
>= (char *) info
->strs
+ strsize
1366 || file_name
< (char *) str
)
1375 /* A line number. If the function was specified, then the value
1376 is relative to the start of the function. Otherwise, the
1377 value is an absolute address. */
1378 val
= ((indexentry
->function_name
? indexentry
->val
: 0)
1379 + bfd_get_32 (abfd
, stab
+ VALOFF
));
1380 /* If this line starts before our desired offset, or if it's
1381 the first line we've been able to find, use it. The
1382 !saw_line check works around a bug in GCC 2.95.3, which emits
1383 the first N_SLINE late. */
1384 if (!saw_line
|| val
<= offset
)
1386 *pline
= bfd_get_16 (abfd
, stab
+ DESCOFF
);
1388 #ifdef ENABLE_CACHING
1389 info
->cached_stab
= stab
;
1390 info
->cached_offset
= val
;
1391 info
->cached_file_name
= file_name
;
1392 info
->cached_indexentry
= indexentry
;
1402 if (saw_func
|| saw_line
)
1414 if (file_name
== NULL
|| IS_ABSOLUTE_PATH (file_name
)
1415 || directory_name
== NULL
)
1416 *pfilename
= file_name
;
1421 dirlen
= strlen (directory_name
);
1422 if (info
->filename
== NULL
1423 || filename_ncmp (info
->filename
, directory_name
, dirlen
) != 0
1424 || filename_cmp (info
->filename
+ dirlen
, file_name
) != 0)
1428 /* Don't free info->filename here. objdump and other
1429 apps keep a copy of a previously returned file name
1431 len
= strlen (file_name
) + 1;
1432 info
->filename
= (char *) bfd_alloc (abfd
, dirlen
+ len
);
1433 if (info
->filename
== NULL
)
1435 memcpy (info
->filename
, directory_name
, dirlen
);
1436 memcpy (info
->filename
+ dirlen
, file_name
, len
);
1439 *pfilename
= info
->filename
;
1442 if (indexentry
->function_name
!= NULL
)
1446 /* This will typically be something like main:F(0,1), so we want
1447 to clobber the colon. It's OK to change the name, since the
1448 string is in our own local storage anyhow. */
1449 s
= strchr (indexentry
->function_name
, ':');
1453 *pfnname
= indexentry
->function_name
;
1460 _bfd_stab_cleanup (bfd
*abfd ATTRIBUTE_UNUSED
, void **pinfo
)
1462 struct stab_find_info
*info
= (struct stab_find_info
*) *pinfo
;
1466 free (info
->indextable
);
1472 _bfd_nosymbols_canonicalize_symtab (bfd
*abfd ATTRIBUTE_UNUSED
,
1473 asymbol
**location ATTRIBUTE_UNUSED
)
1479 _bfd_nosymbols_print_symbol (bfd
*abfd ATTRIBUTE_UNUSED
,
1480 void *afile ATTRIBUTE_UNUSED
,
1481 asymbol
*symbol ATTRIBUTE_UNUSED
,
1482 bfd_print_symbol_type how ATTRIBUTE_UNUSED
)
1487 _bfd_nosymbols_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
1488 asymbol
*sym ATTRIBUTE_UNUSED
,
1489 symbol_info
*ret ATTRIBUTE_UNUSED
)
1494 _bfd_nosymbols_get_symbol_version_string (bfd
*abfd
,
1495 asymbol
*symbol ATTRIBUTE_UNUSED
,
1496 bool base_p ATTRIBUTE_UNUSED
,
1497 bool *hidden ATTRIBUTE_UNUSED
)
1499 return (const char *) _bfd_ptr_bfd_null_error (abfd
);
1503 _bfd_nosymbols_bfd_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1504 const char *name ATTRIBUTE_UNUSED
)
1510 _bfd_nosymbols_get_lineno (bfd
*abfd
, asymbol
*sym ATTRIBUTE_UNUSED
)
1512 return (alent
*) _bfd_ptr_bfd_null_error (abfd
);
1516 _bfd_nosymbols_find_nearest_line
1518 asymbol
**symbols ATTRIBUTE_UNUSED
,
1519 asection
*section ATTRIBUTE_UNUSED
,
1520 bfd_vma offset ATTRIBUTE_UNUSED
,
1521 const char **filename_ptr ATTRIBUTE_UNUSED
,
1522 const char **functionname_ptr ATTRIBUTE_UNUSED
,
1523 unsigned int *line_ptr ATTRIBUTE_UNUSED
,
1524 unsigned int *discriminator_ptr ATTRIBUTE_UNUSED
)
1526 return _bfd_bool_bfd_false_error (abfd
);
1530 _bfd_nosymbols_find_nearest_line_with_alt
1532 const char *alt_filename ATTRIBUTE_UNUSED
,
1533 asymbol
**symbols ATTRIBUTE_UNUSED
,
1534 asection
*section ATTRIBUTE_UNUSED
,
1535 bfd_vma offset ATTRIBUTE_UNUSED
,
1536 const char **filename_ptr ATTRIBUTE_UNUSED
,
1537 const char **functionname_ptr ATTRIBUTE_UNUSED
,
1538 unsigned int *line_ptr ATTRIBUTE_UNUSED
,
1539 unsigned int *discriminator_ptr ATTRIBUTE_UNUSED
)
1541 return _bfd_bool_bfd_false_error (abfd
);
1545 _bfd_nosymbols_find_line (bfd
*abfd
,
1546 asymbol
**symbols ATTRIBUTE_UNUSED
,
1547 asymbol
*symbol ATTRIBUTE_UNUSED
,
1548 const char **filename_ptr ATTRIBUTE_UNUSED
,
1549 unsigned int *line_ptr ATTRIBUTE_UNUSED
)
1551 return _bfd_bool_bfd_false_error (abfd
);
1555 _bfd_nosymbols_find_inliner_info
1557 const char **filename_ptr ATTRIBUTE_UNUSED
,
1558 const char **functionname_ptr ATTRIBUTE_UNUSED
,
1559 unsigned int *line_ptr ATTRIBUTE_UNUSED
)
1561 return _bfd_bool_bfd_false_error (abfd
);
1565 _bfd_nosymbols_bfd_make_debug_symbol (bfd
*abfd
,
1566 void *ptr ATTRIBUTE_UNUSED
,
1567 unsigned long sz ATTRIBUTE_UNUSED
)
1569 return (asymbol
*) _bfd_ptr_bfd_null_error (abfd
);
1573 _bfd_nosymbols_read_minisymbols (bfd
*abfd
,
1574 bool dynamic ATTRIBUTE_UNUSED
,
1575 void **minisymsp ATTRIBUTE_UNUSED
,
1576 unsigned int *sizep ATTRIBUTE_UNUSED
)
1578 return _bfd_long_bfd_n1_error (abfd
);
1582 _bfd_nosymbols_minisymbol_to_symbol (bfd
*abfd
,
1583 bool dynamic ATTRIBUTE_UNUSED
,
1584 const void *minisym ATTRIBUTE_UNUSED
,
1585 asymbol
*sym ATTRIBUTE_UNUSED
)
1587 return (asymbol
*) _bfd_ptr_bfd_null_error (abfd
);
1591 _bfd_nodynamic_get_synthetic_symtab (bfd
*abfd
,
1592 long symcount ATTRIBUTE_UNUSED
,
1593 asymbol
**syms ATTRIBUTE_UNUSED
,
1594 long dynsymcount ATTRIBUTE_UNUSED
,
1595 asymbol
**dynsyms ATTRIBUTE_UNUSED
,
1596 asymbol
**ret ATTRIBUTE_UNUSED
)
1598 return _bfd_long_bfd_n1_error (abfd
);