1 /* Generic BFD library interface and support routines.
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. */
24 typedef bfd, Error reporting, BFD front end, BFD front end
29 A BFD has type <<bfd>>; objects of this type are the
30 cornerstone of any application using BFD. Using BFD
31 consists of making references though the BFD and to data in the BFD.
33 Here is the structure that defines the type <<bfd>>. It
34 contains the major data about the file and pointers
35 to the rest of the data.
38 .typedef enum bfd_format
40 . bfd_unknown = 0, {* File format is unknown. *}
41 . bfd_object, {* Linker/assembler/compiler output. *}
42 . bfd_archive, {* Object archive file. *}
43 . bfd_core, {* Core dump. *}
44 . bfd_type_end {* Marks the end; don't use it! *}
52 . write_direction = 2,
64 .enum bfd_plugin_format
66 . bfd_plugin_unknown = 0,
81 . {* The filename the application opened the BFD with. *}
82 . const char *filename;
84 . {* A pointer to the target jump table. *}
85 . const struct bfd_target *xvec;
87 . {* The IOSTREAM, and corresponding IO vector that provide access
88 . to the file backing the BFD. *}
90 . const struct bfd_iovec *iovec;
92 . {* The caching routines use these to maintain a
93 . least-recently-used list of BFDs. *}
94 . struct bfd *lru_prev, *lru_next;
96 . {* Track current file position (or current buffer offset for
97 . in-memory BFDs). When a file is closed by the caching routines,
98 . BFD retains state information on the file here. *}
101 . {* File modified time, if mtime_set is TRUE. *}
104 . {* A unique identifier of the BFD *}
107 . {* Format_specific flags. *}
110 . {* Values that may appear in the flags field of a BFD. These also
111 . appear in the object_flags field of the bfd_target structure, where
112 . they indicate the set of flags used by that backend (not all flags
113 . are meaningful for all object file formats) (FIXME: at the moment,
114 . the object_flags values have mostly just been copied from backend
115 . to another, and are not necessarily correct). *}
117 .#define BFD_NO_FLAGS 0x0
119 . {* BFD contains relocation entries. *}
120 .#define HAS_RELOC 0x1
122 . {* BFD is directly executable. *}
125 . {* BFD has line number information (basically used for F_LNNO in a
127 .#define HAS_LINENO 0x4
129 . {* BFD has debugging information. *}
130 .#define HAS_DEBUG 0x08
132 . {* BFD has symbols. *}
133 .#define HAS_SYMS 0x10
135 . {* BFD has local symbols (basically used for F_LSYMS in a COFF
137 .#define HAS_LOCALS 0x20
139 . {* BFD is a dynamic object. *}
140 .#define DYNAMIC 0x40
142 . {* Text section is write protected (if D_PAGED is not set, this is
143 . like an a.out NMAGIC file) (the linker sets this by default, but
144 . clears it for -r or -N). *}
145 .#define WP_TEXT 0x80
147 . {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
148 . linker sets this by default, but clears it for -r or -n or -N). *}
149 .#define D_PAGED 0x100
151 . {* BFD is relaxable (this means that bfd_relax_section may be able to
152 . do something) (sometimes bfd_relax_section can do something even if
153 . this is not set). *}
154 .#define BFD_IS_RELAXABLE 0x200
156 . {* This may be set before writing out a BFD to request using a
157 . traditional format. For example, this is used to request that when
158 . writing out an a.out object the symbols not be hashed to eliminate
160 .#define BFD_TRADITIONAL_FORMAT 0x400
162 . {* This flag indicates that the BFD contents are actually cached
163 . in memory. If this is set, iostream points to a bfd_in_memory
165 .#define BFD_IN_MEMORY 0x800
167 . {* This BFD has been created by the linker and doesn't correspond
168 . to any input file. *}
169 .#define BFD_LINKER_CREATED 0x1000
171 . {* This may be set before writing out a BFD to request that it
172 . be written using values for UIDs, GIDs, timestamps, etc. that
173 . will be consistent from run to run. *}
174 .#define BFD_DETERMINISTIC_OUTPUT 0x2000
176 . {* Compress sections in this BFD. *}
177 .#define BFD_COMPRESS 0x4000
179 . {* Decompress sections in this BFD. *}
180 .#define BFD_DECOMPRESS 0x8000
182 . {* BFD is a dummy, for plugins. *}
183 .#define BFD_PLUGIN 0x10000
185 . {* Compress sections in this BFD with SHF_COMPRESSED from gABI. *}
186 .#define BFD_COMPRESS_GABI 0x20000
188 . {* Convert ELF common symbol type to STT_COMMON or STT_OBJECT in this
190 .#define BFD_CONVERT_ELF_COMMON 0x40000
192 . {* Use the ELF STT_COMMON type in this BFD. *}
193 .#define BFD_USE_ELF_STT_COMMON 0x80000
195 . {* Put pathnames into archives (non-POSIX). *}
196 .#define BFD_ARCHIVE_FULL_PATH 0x100000
198 .#define BFD_CLOSED_BY_CACHE 0x200000
200 . {* Compress sections in this BFD with SHF_COMPRESSED zstd. *}
201 .#define BFD_COMPRESS_ZSTD 0x400000
203 . {* Don't generate ELF section header. *}
204 .#define BFD_NO_SECTION_HEADER 0x800000
206 . {* Flags bits which are for BFD use only. *}
207 .#define BFD_FLAGS_FOR_BFD_USE_MASK \
208 . (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
209 . | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT \
210 . | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON \
211 . | BFD_NO_SECTION_HEADER)
213 . {* The format which belongs to the BFD. (object, core, etc.) *}
214 . ENUM_BITFIELD (bfd_format) format : 3;
216 . {* The direction with which the BFD was opened. *}
217 . ENUM_BITFIELD (bfd_direction) direction : 2;
219 . {* POSIX.1-2017 (IEEE Std 1003.1) says of fopen : "When a file is
220 . opened with update mode ('+' as the second or third character in
221 . the mode argument), both input and output may be performed on
222 . the associated stream. However, the application shall ensure
223 . that output is not directly followed by input without an
224 . intervening call to fflush() or to a file positioning function
225 . (fseek(), fsetpos(), or rewind()), and input is not directly
226 . followed by output without an intervening call to a file
227 . positioning function, unless the input operation encounters
229 . This field tracks the last IO operation, so that bfd can insert
230 . a seek when IO direction changes. *}
231 . ENUM_BITFIELD (bfd_last_io) last_io : 2;
233 . {* Is the file descriptor being cached? That is, can it be closed as
234 . needed, and re-opened when accessed later? *}
235 . unsigned int cacheable : 1;
237 . {* Marks whether there was a default target specified when the
238 . BFD was opened. This is used to select which matching algorithm
239 . to use to choose the back end. *}
240 . unsigned int target_defaulted : 1;
242 . {* ... and here: (``once'' means at least once). *}
243 . unsigned int opened_once : 1;
245 . {* Set if we have a locally maintained mtime value, rather than
246 . getting it from the file each time. *}
247 . unsigned int mtime_set : 1;
249 . {* Flag set if symbols from this BFD should not be exported. *}
250 . unsigned int no_export : 1;
252 . {* Remember when output has begun, to stop strange things
254 . unsigned int output_has_begun : 1;
256 . {* Have archive map. *}
257 . unsigned int has_armap : 1;
259 . {* Set if this is a thin archive. *}
260 . unsigned int is_thin_archive : 1;
262 . {* Set if this archive should not cache element positions. *}
263 . unsigned int no_element_cache : 1;
265 . {* Set if only required symbols should be added in the link hash table for
266 . this object. Used by VMS linkers. *}
267 . unsigned int selective_search : 1;
269 . {* Set if this is the linker output BFD. *}
270 . unsigned int is_linker_output : 1;
272 . {* Set if this is the linker input BFD. *}
273 . unsigned int is_linker_input : 1;
275 . {* If this is an input for a compiler plug-in library. *}
276 . ENUM_BITFIELD (bfd_plugin_format) plugin_format : 2;
278 . {* Set if this is a plugin output file. *}
279 . unsigned int lto_output : 1;
281 . {* Set if this is a slim LTO object not loaded with a compiler plugin. *}
282 . unsigned int lto_slim_object : 1;
284 . {* Do not attempt to modify this file. Set when detecting errors
285 . that BFD is not prepared to handle for objcopy/strip. *}
286 . unsigned int read_only : 1;
288 . {* Set to dummy BFD created when claimed by a compiler plug-in
290 . bfd *plugin_dummy_bfd;
292 . {* The offset of this bfd in the file, typically 0 if it is not
293 . contained in an archive. *}
296 . {* The origin in the archive of the proxy entry. This will
297 . normally be the same as origin, except for thin archives,
298 . when it will contain the current offset of the proxy in the
299 . thin archive rather than the offset of the bfd in its actual
301 . ufile_ptr proxy_origin;
303 . {* A hash table for section names. *}
304 . struct bfd_hash_table section_htab;
306 . {* Pointer to linked list of sections. *}
307 . struct bfd_section *sections;
309 . {* The last section on the section list. *}
310 . struct bfd_section *section_last;
312 . {* The number of sections. *}
313 . unsigned int section_count;
315 . {* The archive plugin file descriptor. *}
316 . int archive_plugin_fd;
318 . {* The number of opens on the archive plugin file descriptor. *}
319 . unsigned int archive_plugin_fd_open_count;
321 . {* A field used by _bfd_generic_link_add_archive_symbols. This will
322 . be used only for archive elements. *}
325 . {* The total size of memory from bfd_alloc. *}
326 . bfd_size_type alloc_size;
328 . {* Stuff only useful for object files:
329 . The start address. *}
330 . bfd_vma start_address;
332 . {* Symbol table for output BFD (with symcount entries).
333 . Also used by the linker to cache input BFD symbols. *}
334 . struct bfd_symbol **outsymbols;
336 . {* Used for input and output. *}
337 . unsigned int symcount;
339 . {* Used for slurped dynamic symbol tables. *}
340 . unsigned int dynsymcount;
342 . {* Pointer to structure which contains architecture information. *}
343 . const struct bfd_arch_info *arch_info;
345 . {* Cached length of file for bfd_get_size. 0 until bfd_get_size is
346 . called, 1 if stat returns an error or the file size is too large to
347 . return in ufile_ptr. Both 0 and 1 should be treated as "unknown". *}
350 . {* Stuff only useful for archives. *}
352 . struct bfd *my_archive; {* The containing archive BFD. *}
353 . struct bfd *archive_next; {* The next BFD in the archive. *}
354 . struct bfd *archive_head; {* The first BFD in the archive. *}
355 . struct bfd *nested_archives; {* List of nested archive in a flattened
359 . {* For input BFDs, a chain of BFDs involved in a link. *}
361 . {* For output BFD, the linker hash table. *}
362 . struct bfd_link_hash_table *hash;
365 . {* Used by the back end to hold private data. *}
368 . struct aout_data_struct *aout_data;
369 . struct artdata *aout_ar_data;
370 . struct coff_tdata *coff_obj_data;
371 . struct pe_tdata *pe_obj_data;
372 . struct xcoff_tdata *xcoff_obj_data;
373 . struct ecoff_tdata *ecoff_obj_data;
374 . struct srec_data_struct *srec_data;
375 . struct verilog_data_struct *verilog_data;
376 . struct ihex_data_struct *ihex_data;
377 . struct tekhex_data_struct *tekhex_data;
378 . struct elf_obj_tdata *elf_obj_data;
379 . struct mmo_data_struct *mmo_data;
380 . struct trad_core_struct *trad_core_data;
381 . struct som_data_struct *som_data;
382 . struct hpux_core_struct *hpux_core_data;
383 . struct hppabsd_core_struct *hppabsd_core_data;
384 . struct sgi_core_struct *sgi_core_data;
385 . struct lynx_core_struct *lynx_core_data;
386 . struct osf_core_struct *osf_core_data;
387 . struct cisco_core_struct *cisco_core_data;
388 . struct netbsd_core_struct *netbsd_core_data;
389 . struct mach_o_data_struct *mach_o_data;
390 . struct mach_o_fat_data_struct *mach_o_fat_data;
391 . struct plugin_data_struct *plugin_data;
392 . struct bfd_pef_data_struct *pef_data;
393 . struct bfd_pef_xlib_data_struct *pef_xlib_data;
394 . struct bfd_sym_data_struct *sym_data;
399 . {* Used by the application to hold private data. *}
402 . {* Where all the allocated stuff under this BFD goes. This is a
403 . struct objalloc *, but we use void * to avoid requiring the inclusion
407 . {* For input BFDs, the build ID, if the object has one. *}
408 . const struct bfd_build_id *build_id;
413 .static inline const char *
414 .bfd_get_filename (const bfd *abfd)
416 . return abfd->filename;
420 .bfd_get_cacheable (const bfd *abfd)
422 . return abfd->cacheable;
425 .static inline enum bfd_format
426 .bfd_get_format (const bfd *abfd)
428 . return abfd->format;
431 .static inline flagword
432 .bfd_get_file_flags (const bfd *abfd)
434 . return abfd->flags;
437 .static inline bfd_vma
438 .bfd_get_start_address (const bfd *abfd)
440 . return abfd->start_address;
443 .static inline unsigned int
444 .bfd_get_symcount (const bfd *abfd)
446 . return abfd->symcount;
449 .static inline unsigned int
450 .bfd_get_dynamic_symcount (const bfd *abfd)
452 . return abfd->dynsymcount;
455 .static inline struct bfd_symbol **
456 .bfd_get_outsymbols (const bfd *abfd)
458 . return abfd->outsymbols;
461 .static inline unsigned int
462 .bfd_count_sections (const bfd *abfd)
464 . return abfd->section_count;
468 .bfd_has_map (const bfd *abfd)
470 . return abfd->has_armap;
474 .bfd_is_thin_archive (const bfd *abfd)
476 . return abfd->is_thin_archive;
479 .static inline void *
480 .bfd_usrdata (const bfd *abfd)
482 . return abfd->usrdata;
485 .{* See note beside bfd_set_section_userdata. *}
487 .bfd_set_cacheable (bfd * abfd, bool val)
489 . abfd->cacheable = val;
494 .bfd_set_thin_archive (bfd *abfd, bool val)
496 . abfd->is_thin_archive = val;
500 .bfd_set_usrdata (bfd *abfd, void *val)
502 . abfd->usrdata = val;
505 .static inline asection *
506 .bfd_asymbol_section (const asymbol *sy)
508 . return sy->section;
511 .static inline bfd_vma
512 .bfd_asymbol_value (const asymbol *sy)
514 . return sy->section->vma + sy->value;
517 .static inline const char *
518 .bfd_asymbol_name (const asymbol *sy)
523 .static inline struct bfd *
524 .bfd_asymbol_bfd (const asymbol *sy)
526 . return sy->the_bfd;
530 .bfd_set_asymbol_name (asymbol *sy, const char *name)
535 .{* For input sections return the original size on disk of the
536 . section. For output sections return the current size. *}
537 .static inline bfd_size_type
538 .bfd_get_section_limit_octets (const bfd *abfd, const asection *sec)
540 . if (abfd->direction != write_direction && sec->rawsize != 0)
541 . return sec->rawsize;
545 .{* Find the address one past the end of SEC. *}
546 .static inline bfd_size_type
547 .bfd_get_section_limit (const bfd *abfd, const asection *sec)
549 . return (bfd_get_section_limit_octets (abfd, sec)
550 . / bfd_octets_per_byte (abfd, sec));
553 .{* For input sections return the larger of the current size and the
554 . original size on disk of the section. For output sections return
555 . the current size. *}
556 .static inline bfd_size_type
557 .bfd_get_section_alloc_size (const bfd *abfd, const asection *sec)
559 . if (abfd->direction != write_direction && sec->rawsize > sec->size)
560 . return sec->rawsize;
564 .{* Functions to handle insertion and deletion of a bfd's sections. These
565 . only handle the list pointers, ie. do not adjust section_count,
566 . target_index etc. *}
568 .bfd_section_list_remove (bfd *abfd, asection *s)
570 . asection *next = s->next;
571 . asection *prev = s->prev;
575 . abfd->sections = next;
579 . abfd->section_last = prev;
583 .bfd_section_list_append (bfd *abfd, asection *s)
586 . if (abfd->section_last)
588 . s->prev = abfd->section_last;
589 . abfd->section_last->next = s;
594 . abfd->sections = s;
596 . abfd->section_last = s;
600 .bfd_section_list_prepend (bfd *abfd, asection *s)
603 . if (abfd->sections)
605 . s->next = abfd->sections;
606 . abfd->sections->prev = s;
611 . abfd->section_last = s;
613 . abfd->sections = s;
617 .bfd_section_list_insert_after (bfd *abfd, asection *a, asection *s)
619 . asection *next = a->next;
626 . abfd->section_last = s;
630 .bfd_section_list_insert_before (bfd *abfd, asection *b, asection *s)
632 . asection *prev = b->prev;
639 . abfd->sections = s;
643 .bfd_section_removed_from_list (const bfd *abfd, const asection *s)
645 . return s->next ? s->next->prev != s : abfd->section_last != s;
654 #include "libiberty.h"
655 #include "demangle.h"
656 #include "safe-ctype.h"
659 #include "coff/internal.h"
660 #include "coff/sym.h"
662 #include "libecoff.h"
667 #define EXIT_FAILURE 1
671 /* provide storage for subsystem, stack and heap data which may have been
672 passed in on the command line. Ld puts this data into a bfd_link_info
673 struct which ultimately gets passed in to the bfd. When it arrives, copy
674 it to the following struct so that the data will be available in coffcode.h
675 where it is needed. The typedef's used are defined in bfd.h */
679 Error reporting, Initialization, typedef bfd, BFD front end
684 Most BFD functions return nonzero on success (check their
685 individual documentation for precise semantics). On an error,
686 they call <<bfd_set_error>> to set an error condition that callers
687 can check by calling <<bfd_get_error>>.
688 If that returns <<bfd_error_system_call>>, then check
691 The easiest way to report a BFD error to the user is to
694 The BFD error is thread-local.
697 Type <<bfd_error_type>>
699 The values returned by <<bfd_get_error>> are defined by the
700 enumerated type <<bfd_error_type>>.
703 .typedef enum bfd_error
705 . bfd_error_no_error = 0,
706 . bfd_error_system_call,
707 . bfd_error_invalid_target,
708 . bfd_error_wrong_format,
709 . bfd_error_wrong_object_format,
710 . bfd_error_invalid_operation,
711 . bfd_error_no_memory,
712 . bfd_error_no_symbols,
713 . bfd_error_no_armap,
714 . bfd_error_no_more_archived_files,
715 . bfd_error_malformed_archive,
716 . bfd_error_missing_dso,
717 . bfd_error_file_not_recognized,
718 . bfd_error_file_ambiguously_recognized,
719 . bfd_error_no_contents,
720 . bfd_error_nonrepresentable_section,
721 . bfd_error_no_debug_section,
722 . bfd_error_bad_value,
723 . bfd_error_file_truncated,
724 . bfd_error_file_too_big,
726 . bfd_error_on_input,
727 . bfd_error_invalid_error_code
733 static TLS bfd_error_type bfd_error
;
734 static TLS bfd_error_type input_error
;
735 static TLS bfd
*input_bfd
;
736 static TLS
char *_bfd_error_buf
;
738 const char *const bfd_errmsgs
[] =
741 N_("system call error"),
742 N_("invalid bfd target"),
743 N_("file in wrong format"),
744 N_("archive object file in wrong format"),
745 N_("invalid operation"),
746 N_("memory exhausted"),
748 N_("archive has no index; run ranlib to add one"),
749 N_("no more archived files"),
750 N_("malformed archive"),
751 N_("DSO missing from command line"),
752 N_("file format not recognized"),
753 N_("file format is ambiguous"),
754 N_("section has no contents"),
755 N_("nonrepresentable section on output"),
756 N_("symbol needs debug section which does not exist"),
758 N_("file truncated"),
760 N_("sorry, cannot handle this file"),
761 N_("error reading %s: %s"),
762 N_("#<invalid error code>")
770 bfd_error_type bfd_get_error (void);
773 Return the current BFD error condition.
787 void bfd_set_error (bfd_error_type error_tag);
790 Set the BFD error condition to be @var{error_tag}.
792 @var{error_tag} must not be bfd_error_on_input. Use
793 bfd_set_input_error for input errors instead.
797 bfd_set_error (bfd_error_type error_tag
)
799 bfd_error
= error_tag
;
800 if (bfd_error
>= bfd_error_on_input
)
809 void bfd_set_input_error (bfd *input, bfd_error_type error_tag);
813 Set the BFD error condition to be bfd_error_on_input.
814 @var{input} is the input bfd where the error occurred, and
815 @var{error_tag} the bfd_error_type error.
819 bfd_set_input_error (bfd
*input
, bfd_error_type error_tag
)
821 /* This is an error that occurred during bfd_close when writing an
822 archive, but on one of the input files. */
823 bfd_error
= bfd_error_on_input
;
824 _bfd_clear_error_data ();
826 input_error
= error_tag
;
827 if (input_error
>= bfd_error_on_input
)
836 const char *bfd_errmsg (bfd_error_type error_tag);
839 Return a string describing the error @var{error_tag}, or
840 the system error if @var{error_tag} is <<bfd_error_system_call>>.
844 bfd_errmsg (bfd_error_type error_tag
)
849 if (error_tag
== bfd_error_on_input
)
851 const char *msg
= bfd_errmsg (input_error
);
852 char *ret
= bfd_asprintf (_(bfd_errmsgs
[error_tag
]),
853 bfd_get_filename (input_bfd
), msg
);
857 /* Ick, what to do on out of memory? */
861 if (error_tag
== bfd_error_system_call
)
862 return xstrerror (errno
);
864 if (error_tag
> bfd_error_invalid_error_code
)
865 error_tag
= bfd_error_invalid_error_code
; /* sanity check */
867 return _(bfd_errmsgs
[error_tag
]);
875 void bfd_perror (const char *message);
878 Print to the standard error stream a string describing the
879 last BFD error that occurred, or the last system error if
880 the last BFD error was a system call failure. If @var{message}
881 is non-NULL and non-empty, the error string printed is preceded
882 by @var{message}, a colon, and a space. It is followed by a newline.
886 bfd_perror (const char *message
)
889 if (message
== NULL
|| *message
== '\0')
890 fprintf (stderr
, "%s\n", bfd_errmsg (bfd_get_error ()));
892 fprintf (stderr
, "%s: %s\n", message
, bfd_errmsg (bfd_get_error ()));
898 _bfd_clear_error_data
901 void _bfd_clear_error_data (void);
904 Free any data associated with the BFD error.
908 _bfd_clear_error_data (void)
910 free (_bfd_error_buf
);
911 _bfd_error_buf
= NULL
;
919 char *bfd_asprintf (const char *fmt, ...);
922 Primarily for error reporting, this function is like
923 libiberty's xasprintf except that it can return NULL on no
924 memory and the returned string should not be freed. Uses a
925 thread-local malloc'd buffer managed by libbfd, _bfd_error_buf.
926 Be aware that a call to this function frees the result of any
927 previous call. bfd_errmsg (bfd_error_on_input) also calls
932 bfd_asprintf (const char *fmt
, ...)
934 free (_bfd_error_buf
);
935 _bfd_error_buf
= NULL
;
938 int count
= vasprintf (&_bfd_error_buf
, fmt
, ap
);
942 bfd_set_error (bfd_error_no_memory
);
943 _bfd_error_buf
= NULL
;
945 return _bfd_error_buf
;
952 Some BFD functions want to print messages describing the
953 problem. They call a BFD error handler function. This
954 function may be overridden by the program.
956 The BFD error handler acts like vprintf.
959 .typedef void (*bfd_error_handler_type) (const char *, va_list);
963 /* The program name used when printing BFD error messages. */
965 static const char *_bfd_error_program_name
;
967 /* Support for positional parameters. */
969 union _bfd_doprnt_args
989 /* Maximum number of _bfd_error_handler args. Don't increase this
990 without changing the code handling positional parameters. */
993 /* This macro and _bfd_doprnt taken from libiberty _doprnt.c, tidied a
994 little and extended to handle '%pA', '%pB' and positional parameters. */
996 #define PRINT_TYPE(TYPE, FIELD) \
999 TYPE value = (TYPE) args[arg_no].FIELD; \
1000 result = print (stream, specifier, value); \
1003 typedef int (*print_func
) (void *, const char *, ...);
1006 _bfd_doprnt (print_func print
, void *stream
, const char *format
,
1007 union _bfd_doprnt_args
*args
)
1009 const char *ptr
= format
;
1010 char specifier
[128];
1011 int total_printed
= 0;
1012 unsigned int arg_count
= 0;
1014 while (*ptr
!= '\0')
1020 /* While we have regular characters, print them. */
1021 char *end
= strchr (ptr
, '%');
1023 result
= print (stream
, "%.*s", (int) (end
- ptr
), ptr
);
1025 result
= print (stream
, "%s", ptr
);
1028 else if (ptr
[1] == '%')
1030 fputc ('%', stream
);
1036 /* We have a format specifier! */
1037 char *sptr
= specifier
;
1038 int wide_width
= 0, short_width
= 0;
1039 unsigned int arg_no
;
1041 /* Copy the % and move forward. */
1044 /* Check for a positional parameter. */
1046 if (*ptr
!= '0' && ISDIGIT (*ptr
) && ptr
[1] == '$')
1048 arg_no
= *ptr
- '1';
1052 /* Move past flags. */
1053 while (strchr ("-+ #0'I", *ptr
))
1059 unsigned int arg_index
;
1062 arg_index
= arg_count
;
1063 if (*ptr
!= '0' && ISDIGIT (*ptr
) && ptr
[1] == '$')
1065 arg_index
= *ptr
- '1';
1068 value
= abs (args
[arg_index
].i
);
1070 sptr
+= sprintf (sptr
, "%d", value
);
1073 /* Handle explicit numeric value. */
1074 while (ISDIGIT (*ptr
))
1080 /* Copy and go past the period. */
1085 unsigned int arg_index
;
1088 arg_index
= arg_count
;
1089 if (*ptr
!= '0' && ISDIGIT (*ptr
) && ptr
[1] == '$')
1091 arg_index
= *ptr
- '1';
1094 value
= abs (args
[arg_index
].i
);
1096 sptr
+= sprintf (sptr
, "%d", value
);
1099 /* Handle explicit numeric value. */
1100 while (ISDIGIT (*ptr
))
1103 while (strchr ("hlL", *ptr
))
1122 /* Copy the type specifier, and NULL terminate. */
1125 if ((int) arg_no
< 0)
1138 /* Short values are promoted to int, so just copy it
1139 as an int and trust the C library printf to cast it
1140 to the right width. */
1142 PRINT_TYPE (int, i
);
1148 PRINT_TYPE (int, i
);
1151 PRINT_TYPE (long, l
);
1155 #if defined (__MSVCRT__)
1162 PRINT_TYPE (long long, ll
);
1174 if (wide_width
== 0)
1175 PRINT_TYPE (double, d
);
1177 PRINT_TYPE (long double, ld
);
1181 PRINT_TYPE (char *, p
);
1188 const char *group
= NULL
;
1189 struct coff_comdat_info
*ci
;
1192 sec
= (asection
*) args
[arg_no
].p
;
1194 /* Invoking %pA with a null section pointer is an
1199 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1200 && elf_next_in_group (sec
) != NULL
1201 && (sec
->flags
& SEC_GROUP
) == 0)
1202 group
= elf_group_name (sec
);
1203 else if (abfd
!= NULL
1204 && bfd_get_flavour (abfd
) == bfd_target_coff_flavour
1205 && (ci
= bfd_coff_get_comdat_section (sec
->owner
,
1209 result
= print (stream
, "%s[%s]", sec
->name
, group
);
1211 result
= print (stream
, "%s", sec
->name
);
1213 else if (*ptr
== 'B')
1218 abfd
= (bfd
*) args
[arg_no
].p
;
1220 /* Invoking %pB with a null bfd pointer is an
1223 else if (abfd
->my_archive
1224 && !bfd_is_thin_archive (abfd
->my_archive
))
1225 result
= print (stream
, "%s(%s)",
1226 bfd_get_filename (abfd
->my_archive
),
1227 bfd_get_filename (abfd
));
1229 result
= print (stream
, "%s", bfd_get_filename (abfd
));
1232 PRINT_TYPE (void *, p
);
1241 total_printed
+= result
;
1244 return total_printed
;
1247 /* First pass over FORMAT to gather ARGS. Returns number of args. */
1250 _bfd_doprnt_scan (const char *format
, va_list ap
, union _bfd_doprnt_args
*args
)
1252 const char *ptr
= format
;
1253 unsigned int arg_count
= 0;
1255 for (unsigned int i
= 0; i
< MAX_ARGS
; i
++)
1258 while (*ptr
!= '\0')
1262 ptr
= strchr (ptr
, '%');
1266 else if (ptr
[1] == '%')
1270 int wide_width
= 0, short_width
= 0;
1271 unsigned int arg_no
;
1276 /* Check for a positional parameter. */
1278 if (*ptr
!= '0' && ISDIGIT (*ptr
) && ptr
[1] == '$')
1280 arg_no
= *ptr
- '1';
1284 /* Move past flags. */
1285 while (strchr ("-+ #0'I", *ptr
))
1290 unsigned int arg_index
;
1293 arg_index
= arg_count
;
1294 if (*ptr
!= '0' && ISDIGIT (*ptr
) && ptr
[1] == '$')
1296 arg_index
= *ptr
- '1';
1299 if (arg_index
>= MAX_ARGS
)
1301 args
[arg_index
].type
= Int
;
1305 /* Handle explicit numeric value. */
1306 while (ISDIGIT (*ptr
))
1315 unsigned int arg_index
;
1318 arg_index
= arg_count
;
1319 if (*ptr
!= '0' && ISDIGIT (*ptr
) && ptr
[1] == '$')
1321 arg_index
= *ptr
- '1';
1324 if (arg_index
>= MAX_ARGS
)
1326 args
[arg_index
].type
= Int
;
1330 /* Handle explicit numeric value. */
1331 while (ISDIGIT (*ptr
))
1334 while (strchr ("hlL", *ptr
))
1354 if ((int) arg_no
< 0)
1382 arg_type
= LongLong
;
1394 if (wide_width
== 0)
1397 arg_type
= LongDouble
;
1404 if (*ptr
== 'A' || *ptr
== 'B')
1412 if (arg_no
>= MAX_ARGS
)
1414 args
[arg_no
].type
= arg_type
;
1419 for (unsigned int i
= 0; i
< arg_count
; i
++)
1421 switch (args
[i
].type
)
1424 args
[i
].i
= va_arg (ap
, int);
1427 args
[i
].l
= va_arg (ap
, long);
1430 args
[i
].ll
= va_arg (ap
, long long);
1433 args
[i
].d
= va_arg (ap
, double);
1436 args
[i
].ld
= va_arg (ap
, long double);
1439 args
[i
].p
= va_arg (ap
, void *);
1449 /* The standard error handler that prints to stderr. */
1452 error_handler_fprintf (const char *fmt
, va_list ap
)
1454 union _bfd_doprnt_args args
[MAX_ARGS
];
1456 _bfd_doprnt_scan (fmt
, ap
, args
);
1458 /* PR 4992: Don't interrupt output being sent to stdout. */
1461 fprintf (stderr
, "%s: ", _bfd_get_error_program_name ());
1463 _bfd_doprnt ((print_func
) fprintf
, stderr
, fmt
, args
);
1465 /* On AIX, putc is implemented as a macro that triggers a -Wunused-value
1466 warning, so use the fputc function to avoid it. */
1467 fputc ('\n', stderr
);
1471 /* Control printing to a string buffer. */
1478 /* An fprintf like function that instead prints to a string buffer. */
1481 err_sprintf (void *stream
, const char *fmt
, ...)
1483 struct buf_stream
*s
= stream
;
1487 int total
= vsnprintf (s
->ptr
, s
->left
, fmt
, ap
);
1491 else if (total
> s
->left
)
1504 /* Communicate the bfd processed by bfd_check_format_matches to the
1505 error handling function error_handler_sprintf. */
1507 static bfd
*error_handler_bfd
;
1509 /* An error handler that prints to a string, then dups that string to
1510 a per-xvec cache. */
1513 error_handler_sprintf (const char *fmt
, va_list ap
)
1515 union _bfd_doprnt_args args
[MAX_ARGS
];
1516 char error_buf
[1024];
1517 struct buf_stream error_stream
;
1519 _bfd_doprnt_scan (fmt
, ap
, args
);
1521 error_stream
.ptr
= error_buf
;
1522 error_stream
.left
= sizeof (error_buf
);
1523 _bfd_doprnt (err_sprintf
, &error_stream
, fmt
, args
);
1525 size_t len
= error_stream
.ptr
- error_buf
;
1526 struct per_xvec_message
**warn
1527 = _bfd_per_xvec_warn (error_handler_bfd
->xvec
, len
+ 1);
1530 memcpy ((*warn
)->message
, error_buf
, len
);
1531 (*warn
)->message
[len
] = 0;
1535 /* This is a function pointer to the routine which should handle BFD
1536 error messages. It is called when a BFD routine encounters an
1537 error for which it wants to print a message. Going through a
1538 function pointer permits a program linked against BFD to intercept
1539 the messages and deal with them itself. */
1541 static bfd_error_handler_type _bfd_error_internal
= error_handler_fprintf
;
1548 void _bfd_error_handler (const char *fmt, ...) ATTRIBUTE_PRINTF_1;
1551 This is the default routine to handle BFD error messages.
1552 Like fprintf (stderr, ...), but also handles some extra format
1555 %pA section name from section. For group components, prints
1557 %pB file name from bfd. For archive components, prints
1560 Beware: Only supports a maximum of 9 format arguments.
1564 _bfd_error_handler (const char *fmt
, ...)
1569 _bfd_error_internal (fmt
, ap
);
1575 bfd_set_error_handler
1578 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
1581 Set the BFD error handler function. Returns the previous
1585 bfd_error_handler_type
1586 bfd_set_error_handler (bfd_error_handler_type pnew
)
1588 bfd_error_handler_type pold
;
1590 pold
= _bfd_error_internal
;
1591 _bfd_error_internal
= pnew
;
1597 _bfd_set_error_handler_caching
1600 bfd_error_handler_type _bfd_set_error_handler_caching (bfd *);
1603 Set the BFD error handler function to one that stores messages
1604 to the per_xvec_warn array. Returns the previous function.
1607 bfd_error_handler_type
1608 _bfd_set_error_handler_caching (bfd
*abfd
)
1610 error_handler_bfd
= abfd
;
1611 return bfd_set_error_handler (error_handler_sprintf
);
1616 bfd_set_error_program_name
1619 void bfd_set_error_program_name (const char *);
1622 Set the program name to use when printing a BFD error. This
1623 is printed before the error message followed by a colon and
1624 space. The string must not be changed after it is passed to
1629 bfd_set_error_program_name (const char *name
)
1631 _bfd_error_program_name
= name
;
1636 _bfd_get_error_program_name
1639 const char *_bfd_get_error_program_name (void);
1642 Get the program name used when printing a BFD error.
1646 _bfd_get_error_program_name (void)
1648 if (_bfd_error_program_name
!= NULL
)
1649 return _bfd_error_program_name
;
1657 If BFD finds an internal inconsistency, the bfd assert
1658 handler is called with information on the BFD version, BFD
1659 source file and line. If this happens, most programs linked
1660 against BFD are expected to want to exit with an error, or mark
1661 the current BFD operation as failed, so it is recommended to
1662 override the default handler, which just calls
1663 _bfd_error_handler and continues.
1666 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg,
1667 . const char *bfd_version,
1668 . const char *bfd_file,
1673 /* Note the use of bfd_ prefix on the parameter names above: we want to
1674 show which one is the message and which is the version by naming the
1675 parameters, but avoid polluting the program-using-bfd namespace as
1676 the typedef is visible in the exported headers that the program
1677 includes. Below, it's just for consistency. */
1680 _bfd_default_assert_handler (const char *bfd_formatmsg
,
1681 const char *bfd_version
,
1682 const char *bfd_file
,
1686 _bfd_error_handler (bfd_formatmsg
, bfd_version
, bfd_file
, bfd_line
);
1689 /* Similar to _bfd_error_handler, a program can decide to exit on an
1690 internal BFD error. We use a non-variadic type to simplify passing
1691 on parameters to other functions, e.g. _bfd_error_handler. */
1693 static bfd_assert_handler_type _bfd_assert_handler
= _bfd_default_assert_handler
;
1697 bfd_set_assert_handler
1700 bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type);
1703 Set the BFD assert handler function. Returns the previous
1707 bfd_assert_handler_type
1708 bfd_set_assert_handler (bfd_assert_handler_type pnew
)
1710 bfd_assert_handler_type pold
;
1712 pold
= _bfd_assert_handler
;
1713 _bfd_assert_handler
= pnew
;
1719 Initialization, Threading, Error reporting, BFD front end
1725 unsigned int bfd_init (void);
1728 This routine must be called before any other BFD function to
1729 initialize magical internal data structures.
1730 Returns a magic number, which may be used to check
1731 that the bfd library is configured as expected by users.
1733 .{* Value returned by bfd_init. *}
1734 .#define BFD_INIT_MAGIC (sizeof (struct bfd_section))
1741 bfd_error
= bfd_error_no_error
;
1743 _bfd_clear_error_data ();
1744 input_error
= bfd_error_no_error
;
1745 _bfd_error_program_name
= NULL
;
1746 _bfd_error_internal
= error_handler_fprintf
;
1747 _bfd_assert_handler
= _bfd_default_assert_handler
;
1749 return BFD_INIT_MAGIC
;
1755 Threading, Miscellaneous, Initialization, BFD front end
1760 BFD has limited support for thread-safety. Most BFD globals
1761 are protected by locks, while the error-related globals are
1762 thread-local. A given BFD cannot safely be used from two
1763 threads at the same time; it is up to the application to do
1764 any needed locking. However, it is ok for different threads
1765 to work on different BFD objects at the same time.
1771 .typedef bool (*bfd_lock_unlock_fn_type) (void *);
1774 /* The lock and unlock functions, if set. */
1775 static bfd_lock_unlock_fn_type lock_fn
;
1776 static bfd_lock_unlock_fn_type unlock_fn
;
1777 static void *lock_data
;
1784 bool bfd_thread_init
1785 (bfd_lock_unlock_fn_type lock,
1786 bfd_lock_unlock_fn_type unlock,
1791 Initialize BFD threading. The functions passed in will be
1792 used to lock and unlock global data structures. This may only
1793 be called a single time in a given process. Returns true on
1794 success and false on error. DATA is passed verbatim to the
1795 lock and unlock functions. The lock and unlock functions
1796 should return true on success, or set the BFD error and return
1801 bfd_thread_init (bfd_lock_unlock_fn_type lock
, bfd_lock_unlock_fn_type unlock
,
1804 /* Both functions must be set, and this cannot have been called
1806 if (lock
== NULL
|| unlock
== NULL
|| unlock_fn
!= NULL
)
1808 bfd_set_error (bfd_error_invalid_operation
);
1823 void bfd_thread_cleanup (void);
1826 Clean up any thread-local state. This should be called by a
1827 thread that uses any BFD functions, before the thread exits.
1828 It is fine to call this multiple times, or to call it and then
1829 later call BFD functions on the same thread again.
1833 bfd_thread_cleanup (void)
1835 _bfd_clear_error_data ();
1843 bool bfd_lock (void);
1846 Acquire the global BFD lock, if needed. Returns true on
1847 success, false on error.
1853 if (lock_fn
!= NULL
)
1854 return lock_fn (lock_data
);
1863 bool bfd_unlock (void);
1866 Release the global BFD lock, if needed. Returns true on
1867 success, false on error.
1873 if (unlock_fn
!= NULL
)
1874 return unlock_fn (lock_data
);
1881 Miscellaneous, Memory Usage, Threading, BFD front end
1887 Miscellaneous functions
1892 bfd_get_reloc_upper_bound
1895 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
1898 Return the number of bytes required to store the
1899 relocation information associated with section @var{sect}
1900 attached to bfd @var{abfd}. If an error occurs, return -1.
1905 bfd_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1907 if (abfd
->format
!= bfd_object
)
1909 bfd_set_error (bfd_error_invalid_operation
);
1913 return BFD_SEND (abfd
, _get_reloc_upper_bound
, (abfd
, asect
));
1918 bfd_canonicalize_reloc
1921 long bfd_canonicalize_reloc
1922 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
1925 Call the back end associated with the open BFD
1926 @var{abfd} and translate the external form of the relocation
1927 information attached to @var{sec} into the internal canonical
1928 form. Place the table into memory at @var{loc}, which has
1929 been preallocated, usually by a call to
1930 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or
1933 The @var{syms} table is also needed for horrible internal magic
1938 bfd_canonicalize_reloc (bfd
*abfd
,
1943 if (abfd
->format
!= bfd_object
)
1945 bfd_set_error (bfd_error_invalid_operation
);
1949 return BFD_SEND (abfd
, _bfd_canonicalize_reloc
,
1950 (abfd
, asect
, location
, symbols
));
1959 (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
1962 Set the relocation pointer and count within
1963 section @var{sec} to the values @var{rel} and @var{count}.
1964 The argument @var{abfd} is ignored.
1966 .#define bfd_set_reloc(abfd, asect, location, count) \
1967 . BFD_SEND (abfd, _bfd_set_reloc, (abfd, asect, location, count))
1975 bool bfd_set_file_flags (bfd *abfd, flagword flags);
1978 Set the flag word in the BFD @var{abfd} to the value @var{flags}.
1980 Possible errors are:
1981 o <<bfd_error_wrong_format>> - The target bfd was not of object format.
1982 o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
1983 o <<bfd_error_invalid_operation>> -
1984 The flag word contained a bit which was not applicable to the
1985 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit
1986 on a BFD format which does not support demand paging.
1991 bfd_set_file_flags (bfd
*abfd
, flagword flags
)
1993 if (abfd
->format
!= bfd_object
)
1995 bfd_set_error (bfd_error_wrong_format
);
1999 if (bfd_read_p (abfd
))
2001 bfd_set_error (bfd_error_invalid_operation
);
2005 abfd
->flags
= flags
;
2006 if ((flags
& bfd_applicable_file_flags (abfd
)) != flags
)
2008 bfd_set_error (bfd_error_invalid_operation
);
2016 bfd_assert (const char *file
, int line
)
2018 /* xgettext:c-format */
2019 (*_bfd_assert_handler
) (_("BFD %s assertion fail %s:%d"),
2020 BFD_VERSION_STRING
, file
, line
);
2023 /* A more or less friendly abort message. In libbfd.h abort is
2024 defined to call this function. */
2027 _bfd_abort (const char *file
, int line
, const char *fn
)
2031 /* xgettext:c-format */
2032 (_("BFD %s internal error, aborting at %s:%d in %s\n"),
2033 BFD_VERSION_STRING
, file
, line
, fn
);
2036 /* xgettext:c-format */
2037 (_("BFD %s internal error, aborting at %s:%d\n"),
2038 BFD_VERSION_STRING
, file
, line
);
2039 _bfd_error_handler (_("Please report this bug.\n"));
2040 _exit (EXIT_FAILURE
);
2048 int bfd_get_arch_size (bfd *abfd);
2051 Returns the normalized architecture address size, in bits, as
2052 determined by the object file's format. By normalized, we mean
2053 either 32 or 64. For ELF, this information is included in the
2054 header. Use bfd_arch_bits_per_address for number of bits in
2055 the architecture address.
2057 Returns the arch size in bits if known, <<-1>> otherwise.
2061 bfd_get_arch_size (bfd
*abfd
)
2063 if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
)
2064 return get_elf_backend_data (abfd
)->s
->arch_size
;
2066 return bfd_arch_bits_per_address (abfd
) > 32 ? 64 : 32;
2071 bfd_get_sign_extend_vma
2074 int bfd_get_sign_extend_vma (bfd *abfd);
2077 Indicates if the target architecture "naturally" sign extends
2078 an address. Some architectures implicitly sign extend address
2079 values when they are converted to types larger than the size
2080 of an address. For instance, bfd_get_start_address() will
2081 return an address sign extended to fill a bfd_vma when this is
2084 Returns <<1>> if the target architecture is known to sign
2085 extend addresses, <<0>> if the target architecture is known to
2086 not sign extend addresses, and <<-1>> otherwise.
2090 bfd_get_sign_extend_vma (bfd
*abfd
)
2094 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2095 return get_elf_backend_data (abfd
)->sign_extend_vma
;
2097 name
= bfd_get_target (abfd
);
2099 /* Return a proper value for DJGPP & PE COFF.
2100 This function is required for DWARF2 support, but there is
2101 no place to store this information in the COFF back end.
2102 Should enough other COFF targets add support for DWARF2,
2103 a place will have to be found. Until then, this hack will do. */
2104 if (startswith (name
, "coff-go32")
2105 || strcmp (name
, "pe-i386") == 0
2106 || strcmp (name
, "pei-i386") == 0
2107 || strcmp (name
, "pe-x86-64") == 0
2108 || strcmp (name
, "pei-x86-64") == 0
2109 || strcmp (name
, "pe-aarch64-little") == 0
2110 || strcmp (name
, "pei-aarch64-little") == 0
2111 || strcmp (name
, "pe-arm-wince-little") == 0
2112 || strcmp (name
, "pei-arm-wince-little") == 0
2113 || strcmp (name
, "pei-loongarch64") == 0
2114 || strcmp (name
, "aixcoff-rs6000") == 0
2115 || strcmp (name
, "aix5coff64-rs6000") == 0)
2118 if (startswith (name
, "mach-o"))
2121 bfd_set_error (bfd_error_wrong_format
);
2127 bfd_set_start_address
2130 bool bfd_set_start_address (bfd *abfd, bfd_vma vma);
2133 Make @var{vma} the entry point of output BFD @var{abfd}.
2135 Returns <<TRUE>> on success, <<FALSE>> otherwise.
2139 bfd_set_start_address (bfd
*abfd
, bfd_vma vma
)
2141 abfd
->start_address
= vma
;
2150 unsigned int bfd_get_gp_size (bfd *abfd);
2153 Return the maximum size of objects to be optimized using the GP
2154 register under MIPS ECOFF. This is typically set by the <<-G>>
2155 argument to the compiler, assembler or linker.
2159 bfd_get_gp_size (bfd
*abfd
)
2161 if (abfd
->format
== bfd_object
)
2163 if (abfd
->xvec
->flavour
== bfd_target_ecoff_flavour
)
2164 return ecoff_data (abfd
)->gp_size
;
2165 else if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
)
2166 return elf_gp_size (abfd
);
2176 void bfd_set_gp_size (bfd *abfd, unsigned int i);
2179 Set the maximum size of objects to be optimized using the GP
2180 register under ECOFF or MIPS ELF. This is typically set by
2181 the <<-G>> argument to the compiler, assembler or linker.
2185 bfd_set_gp_size (bfd
*abfd
, unsigned int i
)
2187 /* Don't try to set GP size on an archive or core file! */
2188 if (abfd
->format
!= bfd_object
)
2191 if (abfd
->xvec
->flavour
== bfd_target_ecoff_flavour
)
2192 ecoff_data (abfd
)->gp_size
= i
;
2193 else if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
)
2194 elf_gp_size (abfd
) = i
;
2197 /* Get the GP value. This is an internal function used by some of the
2198 relocation special_function routines on targets which support a GP
2202 _bfd_get_gp_value (bfd
*abfd
)
2206 if (abfd
->format
!= bfd_object
)
2209 if (abfd
->xvec
->flavour
== bfd_target_ecoff_flavour
)
2210 return ecoff_data (abfd
)->gp
;
2211 else if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
)
2212 return elf_gp (abfd
);
2217 /* Set the GP value. */
2220 _bfd_set_gp_value (bfd
*abfd
, bfd_vma v
)
2224 if (abfd
->format
!= bfd_object
)
2227 if (abfd
->xvec
->flavour
== bfd_target_ecoff_flavour
)
2228 ecoff_data (abfd
)->gp
= v
;
2229 else if (abfd
->xvec
->flavour
== bfd_target_elf_flavour
)
2238 void bfd_set_gp_value (bfd *abfd, bfd_vma v);
2241 Allow external access to the fucntion to set the GP value.
2242 This is specifically added for gdb-compile support.
2246 bfd_set_gp_value (bfd
*abfd
, bfd_vma v
)
2248 _bfd_set_gp_value (abfd
, v
);
2256 bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
2259 Convert, like <<strtoul>>, a numerical expression
2260 @var{string} into a <<bfd_vma>> integer, and return that integer.
2261 (Though without as many bells and whistles as <<strtoul>>.)
2262 The expression is assumed to be unsigned (i.e., positive).
2263 If given a @var{base}, it is used as the base for conversion.
2264 A base of 0 causes the function to interpret the string
2265 in hex if a leading "0x" or "0X" is found, otherwise
2266 in octal if a leading zero is found, otherwise in decimal.
2268 If the value would overflow, the maximum <<bfd_vma>> value is
2273 bfd_scan_vma (const char *string
, const char **end
, int base
)
2277 unsigned int cutlim
;
2280 /* Let the host do it if possible. */
2281 if (sizeof (bfd_vma
) <= sizeof (unsigned long))
2282 return strtoul (string
, (char **) end
, base
);
2284 if (sizeof (bfd_vma
) <= sizeof (unsigned long long))
2285 return strtoull (string
, (char **) end
, base
);
2289 if (string
[0] == '0')
2291 if ((string
[1] == 'x') || (string
[1] == 'X'))
2298 if ((base
< 2) || (base
> 36))
2303 && (string
[1] == 'x' || string
[1] == 'X')
2304 && ISXDIGIT (string
[2]))
2309 cutoff
= (~ (bfd_vma
) 0) / (bfd_vma
) base
;
2310 cutlim
= (~ (bfd_vma
) 0) % (bfd_vma
) base
;
2318 if (ISDIGIT (digit
))
2319 digit
= digit
- '0';
2320 else if (ISALPHA (digit
))
2321 digit
= TOUPPER (digit
) - 'A' + 10;
2324 if (digit
>= (unsigned int) base
)
2326 if (value
> cutoff
|| (value
== cutoff
&& digit
> cutlim
))
2328 value
= value
* base
+ digit
;
2333 value
= ~ (bfd_vma
) 0;
2343 bfd_copy_private_header_data
2346 bool bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
2349 Copy private BFD header information from the BFD @var{ibfd} to the
2350 the BFD @var{obfd}. This copies information that may require
2351 sections to exist, but does not require symbol tables. Return
2352 <<true>> on success, <<false>> on error.
2353 Possible error returns are:
2355 o <<bfd_error_no_memory>> -
2356 Not enough memory exists to create private data for @var{obfd}.
2358 .#define bfd_copy_private_header_data(ibfd, obfd) \
2359 . BFD_SEND (obfd, _bfd_copy_private_header_data, \
2366 bfd_copy_private_bfd_data
2369 bool bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
2372 Copy private BFD information from the BFD @var{ibfd} to the
2373 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error.
2374 Possible error returns are:
2376 o <<bfd_error_no_memory>> -
2377 Not enough memory exists to create private data for @var{obfd}.
2379 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
2380 . BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
2387 bfd_set_private_flags
2390 bool bfd_set_private_flags (bfd *abfd, flagword flags);
2393 Set private BFD flag information in the BFD @var{abfd}.
2394 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
2397 o <<bfd_error_no_memory>> -
2398 Not enough memory exists to create private data for @var{obfd}.
2400 .#define bfd_set_private_flags(abfd, flags) \
2401 . BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
2410 The following functions exist but have not yet been documented.
2412 .#define bfd_sizeof_headers(abfd, info) \
2413 . BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
2415 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
2416 . BFD_SEND (abfd, _bfd_find_nearest_line, \
2417 . (abfd, syms, sec, off, file, func, line, NULL))
2419 .#define bfd_find_nearest_line_with_alt(abfd, alt_filename, sec, syms, off, \
2420 . file, func, line, disc) \
2421 . BFD_SEND (abfd, _bfd_find_nearest_line_with_alt, \
2422 . (abfd, alt_filename, syms, sec, off, file, func, line, disc))
2424 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \
2426 . BFD_SEND (abfd, _bfd_find_nearest_line, \
2427 . (abfd, syms, sec, off, file, func, line, disc))
2429 .#define bfd_find_line(abfd, syms, sym, file, line) \
2430 . BFD_SEND (abfd, _bfd_find_line, \
2431 . (abfd, syms, sym, file, line))
2433 .#define bfd_find_inliner_info(abfd, file, func, line) \
2434 . BFD_SEND (abfd, _bfd_find_inliner_info, \
2435 . (abfd, file, func, line))
2437 .#define bfd_debug_info_start(abfd) \
2438 . BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
2440 .#define bfd_debug_info_end(abfd) \
2441 . BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
2443 .#define bfd_debug_info_accumulate(abfd, section) \
2444 . BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
2446 .#define bfd_stat_arch_elt(abfd, stat) \
2447 . BFD_SEND (abfd->my_archive ? abfd->my_archive : abfd, \
2448 . _bfd_stat_arch_elt, (abfd, stat))
2450 .#define bfd_update_armap_timestamp(abfd) \
2451 . BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
2453 .#define bfd_set_arch_mach(abfd, arch, mach)\
2454 . BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
2456 .#define bfd_relax_section(abfd, section, link_info, again) \
2457 . BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
2459 .#define bfd_gc_sections(abfd, link_info) \
2460 . BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
2462 .#define bfd_lookup_section_flags(link_info, flag_info, section) \
2463 . BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section))
2465 .#define bfd_merge_sections(abfd, link_info) \
2466 . BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
2468 .#define bfd_is_group_section(abfd, sec) \
2469 . BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
2471 .#define bfd_group_name(abfd, sec) \
2472 . BFD_SEND (abfd, _bfd_group_name, (abfd, sec))
2474 .#define bfd_discard_group(abfd, sec) \
2475 . BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
2477 .#define bfd_link_hash_table_create(abfd) \
2478 . BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
2480 .#define bfd_link_add_symbols(abfd, info) \
2481 . BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
2483 .#define bfd_link_just_syms(abfd, sec, info) \
2484 . BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
2486 .#define bfd_final_link(abfd, info) \
2487 . BFD_SEND (abfd, _bfd_final_link, (abfd, info))
2489 .#define bfd_free_cached_info(abfd) \
2490 . BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
2492 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
2493 . BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
2495 .#define bfd_print_private_bfd_data(abfd, file)\
2496 . BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
2498 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
2499 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
2501 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
2502 . BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
2503 . dyncount, dynsyms, ret))
2505 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
2506 . BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
2508 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
2509 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
2515 bfd_get_relocated_section_contents
2518 bfd_byte *bfd_get_relocated_section_contents
2519 (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
2523 Read and relocate the indirect link_order section, into DATA
2524 (if non-NULL) or to a malloc'd buffer. Return the buffer, or
2529 bfd_get_relocated_section_contents (bfd
*abfd
,
2530 struct bfd_link_info
*link_info
,
2531 struct bfd_link_order
*link_order
,
2537 bfd_byte
*(*fn
) (bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
2538 bfd_byte
*, bool, asymbol
**);
2540 if (link_order
->type
== bfd_indirect_link_order
)
2542 abfd2
= link_order
->u
.indirect
.section
->owner
;
2549 fn
= abfd2
->xvec
->_bfd_get_relocated_section_contents
;
2551 return (*fn
) (abfd
, link_info
, link_order
, data
, relocatable
, symbols
);
2559 bool bfd_record_phdr
2560 (bfd *, unsigned long, bool, flagword, bool, bfd_vma,
2561 bool, bool, unsigned int, struct bfd_section **);
2564 Record information about an ELF program header.
2568 bfd_record_phdr (bfd
*abfd
,
2573 bfd_vma at
, /* Bytes. */
2574 bool includes_filehdr
,
2575 bool includes_phdrs
,
2579 struct elf_segment_map
*m
, **pm
;
2581 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
2583 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
2586 amt
= sizeof (struct elf_segment_map
);
2587 amt
+= ((bfd_size_type
) count
- 1) * sizeof (asection
*);
2588 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
2594 m
->p_paddr
= at
* opb
;
2595 m
->p_flags_valid
= flags_valid
;
2596 m
->p_paddr_valid
= at_valid
;
2597 m
->includes_filehdr
= includes_filehdr
;
2598 m
->includes_phdrs
= includes_phdrs
;
2601 memcpy (m
->sections
, secs
, count
* sizeof (asection
*));
2603 for (pm
= &elf_seg_map (abfd
); *pm
!= NULL
; pm
= &(*pm
)->next
)
2611 /* Return true iff this target is 32-bit. */
2616 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2618 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2619 return bed
->s
->elfclass
== ELFCLASS32
;
2622 /* For non-ELF targets, use architecture information. */
2623 return bfd_arch_bits_per_address (abfd
) <= 32;
2633 void bfd_sprintf_vma (bfd *, char *, bfd_vma);
2634 void bfd_fprintf_vma (bfd *, void *, bfd_vma);
2637 bfd_sprintf_vma and bfd_fprintf_vma display an address in the
2638 target's address size.
2641 .#define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd, stdout, x)
2646 bfd_sprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, char *buf
, bfd_vma value
)
2649 if (!is32bit (abfd
))
2651 sprintf (buf
, "%016" PRIx64
, (uint64_t) value
);
2655 sprintf (buf
, "%08lx", (unsigned long) value
& 0xffffffff);
2659 bfd_fprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, void *stream
, bfd_vma value
)
2662 if (!is32bit (abfd
))
2664 fprintf ((FILE *) stream
, "%016" PRIx64
, (uint64_t) value
);
2668 fprintf ((FILE *) stream
, "%08lx", (unsigned long) value
& 0xffffffff);
2676 bool bfd_alt_mach_code (bfd *abfd, int alternative);
2680 When more than one machine code number is available for the
2681 same machine type, this function can be used to switch between
2682 the preferred one (alternative == 0) and any others. Currently,
2683 only ELF supports this feature, with up to two alternate
2688 bfd_alt_mach_code (bfd
*abfd
, int alternative
)
2690 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2694 switch (alternative
)
2697 code
= get_elf_backend_data (abfd
)->elf_machine_code
;
2701 code
= get_elf_backend_data (abfd
)->elf_machine_alt1
;
2707 code
= get_elf_backend_data (abfd
)->elf_machine_alt2
;
2716 elf_elfheader (abfd
)->e_machine
= code
;
2726 bfd_emul_get_maxpagesize
2729 bfd_vma bfd_emul_get_maxpagesize (const char *);
2732 Returns the maximum page size, in bytes, as determined by
2737 bfd_emul_get_maxpagesize (const char *emul
)
2739 const bfd_target
*target
;
2741 target
= bfd_find_target (emul
, NULL
);
2743 && target
->flavour
== bfd_target_elf_flavour
)
2744 return xvec_get_elf_backend_data (target
)->maxpagesize
;
2751 bfd_emul_get_commonpagesize
2754 bfd_vma bfd_emul_get_commonpagesize (const char *);
2757 Returns the common page size, in bytes, as determined by
2762 bfd_emul_get_commonpagesize (const char *emul
)
2764 const bfd_target
*target
;
2766 target
= bfd_find_target (emul
, NULL
);
2768 && target
->flavour
== bfd_target_elf_flavour
)
2770 const struct elf_backend_data
*bed
;
2772 bed
= xvec_get_elf_backend_data (target
);
2773 return bed
->commonpagesize
;
2783 char *bfd_demangle (bfd *, const char *, int);
2786 Wrapper around cplus_demangle. Strips leading underscores and
2787 other such chars that would otherwise confuse the demangler.
2788 If passed a g++ v3 ABI mangled name, returns a buffer allocated
2789 with malloc holding the demangled name. Returns NULL otherwise
2790 and on memory alloc failure.
2794 bfd_demangle (bfd
*abfd
, const char *name
, int options
)
2797 const char *pre
, *suf
;
2801 skip_lead
= (abfd
!= NULL
2803 && bfd_get_symbol_leading_char (abfd
) == *name
);
2807 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
2808 or the MS PE format. These formats have a number of leading '.'s
2809 on at least some symbols, so we remove all dots to avoid
2810 confusing the demangler. */
2812 while (*name
== '.' || *name
== '$')
2814 pre_len
= name
- pre
;
2816 /* Strip off @plt and suchlike too. */
2818 suf
= strchr (name
, '@');
2821 alloc
= (char *) bfd_malloc (suf
- name
+ 1);
2824 memcpy (alloc
, name
, suf
- name
);
2825 alloc
[suf
- name
] = '\0';
2829 res
= cplus_demangle (name
, options
);
2837 size_t len
= strlen (pre
) + 1;
2838 alloc
= (char *) bfd_malloc (len
);
2841 memcpy (alloc
, pre
, len
);
2847 /* Put back any prefix or suffix. */
2848 if (pre_len
!= 0 || suf
!= NULL
)
2857 suf_len
= strlen (suf
) + 1;
2858 final
= (char *) bfd_malloc (pre_len
+ len
+ suf_len
);
2861 memcpy (final
, pre
, pre_len
);
2862 memcpy (final
+ pre_len
, res
, len
);
2863 memcpy (final
+ pre_len
+ len
, suf
, suf_len
);
2872 /* Get the linker information. */
2874 struct bfd_link_info
*
2875 _bfd_get_link_info (bfd
*abfd
)
2877 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
2880 return elf_link_info (abfd
);