1 /* Generic BFD library interface and support routines.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
28 A BFD has type <<bfd>>; objects of this type are the
29 cornerstone of any application using BFD. Using BFD
30 consists of making references though the BFD and to data in the BFD.
32 Here is the structure that defines the type <<bfd>>. It
33 contains the major data about the file and pointers
34 to the rest of the data.
42 . write_direction = 2,
48 . {* A unique identifier of the BFD *}
51 . {* The filename the application opened the BFD with. *}
52 . const char *filename;
54 . {* A pointer to the target jump table. *}
55 . const struct bfd_target *xvec;
57 . {* The IOSTREAM, and corresponding IO vector that provide access
58 . to the file backing the BFD. *}
60 . const struct bfd_iovec *iovec;
62 . {* The caching routines use these to maintain a
63 . least-recently-used list of BFDs. *}
64 . struct bfd *lru_prev, *lru_next;
66 . {* When a file is closed by the caching routines, BFD retains
67 . state information on the file here... *}
70 . {* File modified time, if mtime_set is TRUE. *}
73 . {* Reserved for an unimplemented file locking extension. *}
76 . {* The format which belongs to the BFD. (object, core, etc.) *}
79 . {* The direction with which the BFD was opened. *}
80 . enum bfd_direction direction;
82 . {* Format_specific flags. *}
85 . {* Values that may appear in the flags field of a BFD. These also
86 . appear in the object_flags field of the bfd_target structure, where
87 . they indicate the set of flags used by that backend (not all flags
88 . are meaningful for all object file formats) (FIXME: at the moment,
89 . the object_flags values have mostly just been copied from backend
90 . to another, and are not necessarily correct). *}
92 .#define BFD_NO_FLAGS 0x00
94 . {* BFD contains relocation entries. *}
95 .#define HAS_RELOC 0x01
97 . {* BFD is directly executable. *}
100 . {* BFD has line number information (basically used for F_LNNO in a
102 .#define HAS_LINENO 0x04
104 . {* BFD has debugging information. *}
105 .#define HAS_DEBUG 0x08
107 . {* BFD has symbols. *}
108 .#define HAS_SYMS 0x10
110 . {* BFD has local symbols (basically used for F_LSYMS in a COFF
112 .#define HAS_LOCALS 0x20
114 . {* BFD is a dynamic object. *}
115 .#define DYNAMIC 0x40
117 . {* Text section is write protected (if D_PAGED is not set, this is
118 . like an a.out NMAGIC file) (the linker sets this by default, but
119 . clears it for -r or -N). *}
120 .#define WP_TEXT 0x80
122 . {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
123 . linker sets this by default, but clears it for -r or -n or -N). *}
124 .#define D_PAGED 0x100
126 . {* BFD is relaxable (this means that bfd_relax_section may be able to
127 . do something) (sometimes bfd_relax_section can do something even if
128 . this is not set). *}
129 .#define BFD_IS_RELAXABLE 0x200
131 . {* This may be set before writing out a BFD to request using a
132 . traditional format. For example, this is used to request that when
133 . writing out an a.out object the symbols not be hashed to eliminate
135 .#define BFD_TRADITIONAL_FORMAT 0x400
137 . {* This flag indicates that the BFD contents are actually cached
138 . in memory. If this is set, iostream points to a bfd_in_memory
140 .#define BFD_IN_MEMORY 0x800
142 . {* The sections in this BFD specify a memory page. *}
143 .#define HAS_LOAD_PAGE 0x1000
145 . {* This BFD has been created by the linker and doesn't correspond
146 . to any input file. *}
147 .#define BFD_LINKER_CREATED 0x2000
149 . {* This may be set before writing out a BFD to request that it
150 . be written using values for UIDs, GIDs, timestamps, etc. that
151 . will be consistent from run to run. *}
152 .#define BFD_DETERMINISTIC_OUTPUT 0x4000
154 . {* Compress sections in this BFD. *}
155 .#define BFD_COMPRESS 0x8000
157 . {* Decompress sections in this BFD. *}
158 .#define BFD_DECOMPRESS 0x10000
160 . {* Flags bits to be saved in bfd_preserve_save. *}
161 .#define BFD_FLAGS_SAVED \
162 . (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS)
164 . {* Currently my_archive is tested before adding origin to
165 . anything. I believe that this can become always an add of
166 . origin, with origin set to 0 for non archive files. *}
169 . {* The origin in the archive of the proxy entry. This will
170 . normally be the same as origin, except for thin archives,
171 . when it will contain the current offset of the proxy in the
172 . thin archive rather than the offset of the bfd in its actual
174 . ufile_ptr proxy_origin;
176 . {* A hash table for section names. *}
177 . struct bfd_hash_table section_htab;
179 . {* Pointer to linked list of sections. *}
180 . struct bfd_section *sections;
182 . {* The last section on the section list. *}
183 . struct bfd_section *section_last;
185 . {* The number of sections. *}
186 . unsigned int section_count;
188 . {* Stuff only useful for object files:
189 . The start address. *}
190 . bfd_vma start_address;
192 . {* Used for input and output. *}
193 . unsigned int symcount;
195 . {* Symbol table for output BFD (with symcount entries).
196 . Also used by the linker to cache input BFD symbols. *}
197 . struct bfd_symbol **outsymbols;
199 . {* Used for slurped dynamic symbol tables. *}
200 . unsigned int dynsymcount;
202 . {* Pointer to structure which contains architecture information. *}
203 . const struct bfd_arch_info *arch_info;
205 . {* Stuff only useful for archives. *}
207 . struct bfd *my_archive; {* The containing archive BFD. *}
208 . struct bfd *archive_next; {* The next BFD in the archive. *}
209 . struct bfd *archive_head; {* The first BFD in the archive. *}
210 . struct bfd *nested_archives; {* List of nested archive in a flattened
213 . {* A chain of BFD structures involved in a link. *}
214 . struct bfd *link_next;
216 . {* A field used by _bfd_generic_link_add_archive_symbols. This will
217 . be used only for archive elements. *}
220 . {* Used by the back end to hold private data. *}
223 . struct aout_data_struct *aout_data;
224 . struct artdata *aout_ar_data;
225 . struct _oasys_data *oasys_obj_data;
226 . struct _oasys_ar_data *oasys_ar_data;
227 . struct coff_tdata *coff_obj_data;
228 . struct pe_tdata *pe_obj_data;
229 . struct xcoff_tdata *xcoff_obj_data;
230 . struct ecoff_tdata *ecoff_obj_data;
231 . struct ieee_data_struct *ieee_data;
232 . struct ieee_ar_data_struct *ieee_ar_data;
233 . struct srec_data_struct *srec_data;
234 . struct verilog_data_struct *verilog_data;
235 . struct ihex_data_struct *ihex_data;
236 . struct tekhex_data_struct *tekhex_data;
237 . struct elf_obj_tdata *elf_obj_data;
238 . struct nlm_obj_tdata *nlm_obj_data;
239 . struct bout_data_struct *bout_data;
240 . struct mmo_data_struct *mmo_data;
241 . struct sun_core_struct *sun_core_data;
242 . struct sco5_core_struct *sco5_core_data;
243 . struct trad_core_struct *trad_core_data;
244 . struct som_data_struct *som_data;
245 . struct hpux_core_struct *hpux_core_data;
246 . struct hppabsd_core_struct *hppabsd_core_data;
247 . struct sgi_core_struct *sgi_core_data;
248 . struct lynx_core_struct *lynx_core_data;
249 . struct osf_core_struct *osf_core_data;
250 . struct cisco_core_struct *cisco_core_data;
251 . struct versados_data_struct *versados_data;
252 . struct netbsd_core_struct *netbsd_core_data;
253 . struct mach_o_data_struct *mach_o_data;
254 . struct mach_o_fat_data_struct *mach_o_fat_data;
255 . struct plugin_data_struct *plugin_data;
256 . struct bfd_pef_data_struct *pef_data;
257 . struct bfd_pef_xlib_data_struct *pef_xlib_data;
258 . struct bfd_sym_data_struct *sym_data;
263 . {* Used by the application to hold private data. *}
266 . {* Where all the allocated stuff under this BFD goes. This is a
267 . struct objalloc *, but we use void * to avoid requiring the inclusion
271 . {* Is the file descriptor being cached? That is, can it be closed as
272 . needed, and re-opened when accessed later? *}
273 . unsigned int cacheable : 1;
275 . {* Marks whether there was a default target specified when the
276 . BFD was opened. This is used to select which matching algorithm
277 . to use to choose the back end. *}
278 . unsigned int target_defaulted : 1;
280 . {* ... and here: (``once'' means at least once). *}
281 . unsigned int opened_once : 1;
283 . {* Set if we have a locally maintained mtime value, rather than
284 . getting it from the file each time. *}
285 . unsigned int mtime_set : 1;
287 . {* Flag set if symbols from this BFD should not be exported. *}
288 . unsigned int no_export : 1;
290 . {* Remember when output has begun, to stop strange things
292 . unsigned int output_has_begun : 1;
294 . {* Have archive map. *}
295 . unsigned int has_armap : 1;
297 . {* Set if this is a thin archive. *}
298 . unsigned int is_thin_archive : 1;
300 . {* Set if only required symbols should be added in the link hash table for
301 . this object. Used by VMS linkers. *}
302 . unsigned int selective_search : 1;
311 #include "libiberty.h"
312 #include "demangle.h"
313 #include "safe-ctype.h"
316 #include "coff/internal.h"
317 #include "coff/sym.h"
319 #include "libecoff.h"
324 #define EXIT_FAILURE 1
328 /* provide storage for subsystem, stack and heap data which may have been
329 passed in on the command line. Ld puts this data into a bfd_link_info
330 struct which ultimately gets passed in to the bfd. When it arrives, copy
331 it to the following struct so that the data will be available in coffcode.h
332 where it is needed. The typedef's used are defined in bfd.h */
338 Most BFD functions return nonzero on success (check their
339 individual documentation for precise semantics). On an error,
340 they call <<bfd_set_error>> to set an error condition that callers
341 can check by calling <<bfd_get_error>>.
342 If that returns <<bfd_error_system_call>>, then check
345 The easiest way to report a BFD error to the user is to
349 Type <<bfd_error_type>>
351 The values returned by <<bfd_get_error>> are defined by the
352 enumerated type <<bfd_error_type>>.
356 .typedef enum bfd_error
358 . bfd_error_no_error = 0,
359 . bfd_error_system_call,
360 . bfd_error_invalid_target,
361 . bfd_error_wrong_format,
362 . bfd_error_wrong_object_format,
363 . bfd_error_invalid_operation,
364 . bfd_error_no_memory,
365 . bfd_error_no_symbols,
366 . bfd_error_no_armap,
367 . bfd_error_no_more_archived_files,
368 . bfd_error_malformed_archive,
369 . bfd_error_file_not_recognized,
370 . bfd_error_file_ambiguously_recognized,
371 . bfd_error_no_contents,
372 . bfd_error_nonrepresentable_section,
373 . bfd_error_no_debug_section,
374 . bfd_error_bad_value,
375 . bfd_error_file_truncated,
376 . bfd_error_file_too_big,
377 . bfd_error_on_input,
378 . bfd_error_invalid_error_code
384 static bfd_error_type bfd_error = bfd_error_no_error;
385 static bfd *input_bfd = NULL;
386 static bfd_error_type input_error = bfd_error_no_error;
388 const char *const bfd_errmsgs[] =
391 N_("System call error"),
392 N_("Invalid bfd target"),
393 N_("File in wrong format"),
394 N_("Archive object file in wrong format"),
395 N_("Invalid operation"),
396 N_("Memory exhausted"),
398 N_("Archive has no index; run ranlib to add one"),
399 N_("No more archived files"),
400 N_("Malformed archive"),
401 N_("File format not recognized"),
402 N_("File format is ambiguous"),
403 N_("Section has no contents"),
404 N_("Nonrepresentable section on output"),
405 N_("Symbol needs debug section which does not exist"),
407 N_("File truncated"),
409 N_("Error reading %s: %s"),
410 N_("#<Invalid error code>")
418 bfd_error_type bfd_get_error (void);
421 Return the current BFD error condition.
435 void bfd_set_error (bfd_error_type error_tag, ...);
438 Set the BFD error condition to be @var{error_tag}.
439 If @var{error_tag} is bfd_error_on_input, then this function
440 takes two more parameters, the input bfd where the error
441 occurred, and the bfd_error_type error.
445 bfd_set_error (bfd_error_type error_tag, ...)
447 bfd_error = error_tag;
448 if (error_tag == bfd_error_on_input)
450 /* This is an error that occurred during bfd_close when
451 writing an archive, but on one of the input files. */
454 va_start (ap, error_tag);
455 input_bfd = va_arg (ap, bfd *);
456 input_error = (bfd_error_type) va_arg (ap, int);
457 if (input_error >= bfd_error_on_input)
468 const char *bfd_errmsg (bfd_error_type error_tag);
471 Return a string describing the error @var{error_tag}, or
472 the system error if @var{error_tag} is <<bfd_error_system_call>>.
476 bfd_errmsg (bfd_error_type error_tag)
481 if (error_tag == bfd_error_on_input)
484 const char *msg = bfd_errmsg (input_error);
486 if (asprintf (&buf, _(bfd_errmsgs [error_tag]), input_bfd->filename, msg)
490 /* Ick, what to do on out of memory? */
494 if (error_tag == bfd_error_system_call)
495 return xstrerror (errno);
497 if (error_tag > bfd_error_invalid_error_code)
498 error_tag = bfd_error_invalid_error_code; /* sanity check */
500 return _(bfd_errmsgs [error_tag]);
508 void bfd_perror (const char *message);
511 Print to the standard error stream a string describing the
512 last BFD error that occurred, or the last system error if
513 the last BFD error was a system call failure. If @var{message}
514 is non-NULL and non-empty, the error string printed is preceded
515 by @var{message}, a colon, and a space. It is followed by a newline.
519 bfd_perror (const char *message)
521 if (message == NULL || *message == '\0')
522 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
524 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
531 Some BFD functions want to print messages describing the
532 problem. They call a BFD error handler function. This
533 function may be overridden by the program.
535 The BFD error handler acts like printf.
539 .typedef void (*bfd_error_handler_type) (const char *, ...);
543 /* The program name used when printing BFD error messages. */
545 static const char *_bfd_error_program_name;
547 /* This is the default routine to handle BFD error messages.
548 Like fprintf (stderr, ...), but also handles some extra format specifiers.
550 %A section name from section. For group components, print group name too.
551 %B file name from bfd. For archive components, prints archive too.
553 Note - because these two extra format specifiers require special handling
554 they are scanned for and processed in this function, before calling
555 vfprintf. This means that the *arguments* for these format specifiers
556 must be the first ones in the variable argument list, regardless of where
557 the specifiers appear in the format string. Thus for example calling
558 this function with a format string of:
560 "blah %s blah %A blah %d blah %B"
562 would involve passing the arguments as:
564 "blah %s blah %A blah %d blah %B",
572 _bfd_default_error_handler (const char *fmt, ...)
576 const char *new_fmt, *p;
580 /* PR 4992: Don't interrupt output being sent to stdout. */
583 if (_bfd_error_program_name != NULL)
584 fprintf (stderr, "%s: ", _bfd_error_program_name);
586 fprintf (stderr, "BFD: ");
592 /* Reserve enough space for the existing format string. */
593 avail -= strlen (fmt) + 1;
595 _exit (EXIT_FAILURE);
601 size_t len, extra, trim;
604 if (p == NULL || p[1] == '\0')
609 memcpy (bufp, fmt, len + 1);
614 if (p[1] == 'A' || p[1] == 'B')
617 memcpy (bufp, fmt, len);
622 /* If we run out of space, tough, you lose your ridiculously
623 long file or section name. It's not safe to try to alloc
624 memory here; We might be printing an out of memory message. */
635 bfd *abfd = va_arg (ap, bfd *);
638 /* Invoking %B with a null bfd pointer is an internal error. */
640 else if (abfd->my_archive)
641 snprintf (bufp, avail, "%s(%s)",
642 abfd->my_archive->filename, abfd->filename);
644 snprintf (bufp, avail, "%s", abfd->filename);
648 asection *sec = va_arg (ap, asection *);
650 const char *group = NULL;
651 struct coff_comdat_info *ci;
654 /* Invoking %A with a null section pointer is an internal error. */
658 && bfd_get_flavour (abfd) == bfd_target_elf_flavour
659 && elf_next_in_group (sec) != NULL
660 && (sec->flags & SEC_GROUP) == 0)
661 group = elf_group_name (sec);
662 else if (abfd != NULL
663 && bfd_get_flavour (abfd) == bfd_target_coff_flavour
664 && (ci = bfd_coff_get_comdat_section (sec->owner,
668 snprintf (bufp, avail, "%s[%s]", sec->name, group);
670 snprintf (bufp, avail, "%s", sec->name);
673 avail = avail - len + 2;
675 /* We need to replace any '%' we printed by "%%".
676 First count how many. */
680 while ((q = strchr (q, '%')) != NULL)
686 /* If there isn't room, trim off the end of the string. */
691 trim = extra - avail;
704 /* Now double all '%' chars, shuffling the string as we go. */
707 while ((q[extra] = *q) != '%')
717 vfprintf (stderr, new_fmt, ap);
723 /* This is a function pointer to the routine which should handle BFD
724 error messages. It is called when a BFD routine encounters an
725 error for which it wants to print a message. Going through a
726 function pointer permits a program linked against BFD to intercept
727 the messages and deal with them itself. */
729 bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler;
733 bfd_set_error_handler
736 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
739 Set the BFD error handler function. Returns the previous
743 bfd_error_handler_type
744 bfd_set_error_handler (bfd_error_handler_type pnew)
746 bfd_error_handler_type pold;
748 pold = _bfd_error_handler;
749 _bfd_error_handler = pnew;
755 bfd_set_error_program_name
758 void bfd_set_error_program_name (const char *);
761 Set the program name to use when printing a BFD error. This
762 is printed before the error message followed by a colon and
763 space. The string must not be changed after it is passed to
768 bfd_set_error_program_name (const char *name)
770 _bfd_error_program_name = name;
775 bfd_get_error_handler
778 bfd_error_handler_type bfd_get_error_handler (void);
781 Return the BFD error handler function.
784 bfd_error_handler_type
785 bfd_get_error_handler (void)
787 return _bfd_error_handler;
795 Miscellaneous functions
800 bfd_get_reloc_upper_bound
803 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
806 Return the number of bytes required to store the
807 relocation information associated with section @var{sect}
808 attached to bfd @var{abfd}. If an error occurs, return -1.
813 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
815 if (abfd->format != bfd_object)
817 bfd_set_error (bfd_error_invalid_operation);
821 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
826 bfd_canonicalize_reloc
829 long bfd_canonicalize_reloc
830 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
833 Call the back end associated with the open BFD
834 @var{abfd} and translate the external form of the relocation
835 information attached to @var{sec} into the internal canonical
836 form. Place the table into memory at @var{loc}, which has
837 been preallocated, usually by a call to
838 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or
841 The @var{syms} table is also needed for horrible internal magic
846 bfd_canonicalize_reloc (bfd *abfd,
851 if (abfd->format != bfd_object)
853 bfd_set_error (bfd_error_invalid_operation);
857 return BFD_SEND (abfd, _bfd_canonicalize_reloc,
858 (abfd, asect, location, symbols));
867 (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
870 Set the relocation pointer and count within
871 section @var{sec} to the values @var{rel} and @var{count}.
872 The argument @var{abfd} is ignored.
877 bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED,
882 asect->orelocation = location;
883 asect->reloc_count = count;
891 bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
894 Set the flag word in the BFD @var{abfd} to the value @var{flags}.
897 o <<bfd_error_wrong_format>> - The target bfd was not of object format.
898 o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
899 o <<bfd_error_invalid_operation>> -
900 The flag word contained a bit which was not applicable to the
901 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit
902 on a BFD format which does not support demand paging.
907 bfd_set_file_flags (bfd *abfd, flagword flags)
909 if (abfd->format != bfd_object)
911 bfd_set_error (bfd_error_wrong_format);
915 if (bfd_read_p (abfd))
917 bfd_set_error (bfd_error_invalid_operation);
921 bfd_get_file_flags (abfd) = flags;
922 if ((flags & bfd_applicable_file_flags (abfd)) != flags)
924 bfd_set_error (bfd_error_invalid_operation);
932 bfd_assert (const char *file, int line)
934 (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"),
935 BFD_VERSION_STRING, file, line);
938 /* A more or less friendly abort message. In libbfd.h abort is
939 defined to call this function. */
942 _bfd_abort (const char *file, int line, const char *fn)
945 (*_bfd_error_handler)
946 (_("BFD %s internal error, aborting at %s line %d in %s\n"),
947 BFD_VERSION_STRING, file, line, fn);
949 (*_bfd_error_handler)
950 (_("BFD %s internal error, aborting at %s line %d\n"),
951 BFD_VERSION_STRING, file, line);
952 (*_bfd_error_handler) (_("Please report this bug.\n"));
953 _exit (EXIT_FAILURE);
961 int bfd_get_arch_size (bfd *abfd);
964 Returns the architecture address size, in bits, as determined
965 by the object file's format. For ELF, this information is
966 included in the header.
969 Returns the arch size in bits if known, <<-1>> otherwise.
973 bfd_get_arch_size (bfd *abfd)
975 if (abfd->xvec->flavour == bfd_target_elf_flavour)
976 return get_elf_backend_data (abfd)->s->arch_size;
983 bfd_get_sign_extend_vma
986 int bfd_get_sign_extend_vma (bfd *abfd);
989 Indicates if the target architecture "naturally" sign extends
990 an address. Some architectures implicitly sign extend address
991 values when they are converted to types larger than the size
992 of an address. For instance, bfd_get_start_address() will
993 return an address sign extended to fill a bfd_vma when this is
997 Returns <<1>> if the target architecture is known to sign
998 extend addresses, <<0>> if the target architecture is known to
999 not sign extend addresses, and <<-1>> otherwise.
1003 bfd_get_sign_extend_vma (bfd *abfd)
1007 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1008 return get_elf_backend_data (abfd)->sign_extend_vma;
1010 name = bfd_get_target (abfd);
1012 /* Return a proper value for DJGPP & PE COFF.
1013 This function is required for DWARF2 support, but there is
1014 no place to store this information in the COFF back end.
1015 Should enough other COFF targets add support for DWARF2,
1016 a place will have to be found. Until then, this hack will do. */
1017 if (CONST_STRNEQ (name, "coff-go32")
1018 || strcmp (name, "pe-i386") == 0
1019 || strcmp (name, "pei-i386") == 0
1020 || strcmp (name, "pe-x86-64") == 0
1021 || strcmp (name, "pei-x86-64") == 0
1022 || strcmp (name, "pe-arm-wince-little") == 0
1023 || strcmp (name, "pei-arm-wince-little") == 0)
1026 if (CONST_STRNEQ (name, "mach-o"))
1029 bfd_set_error (bfd_error_wrong_format);
1035 bfd_set_start_address
1038 bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
1041 Make @var{vma} the entry point of output BFD @var{abfd}.
1044 Returns <<TRUE>> on success, <<FALSE>> otherwise.
1048 bfd_set_start_address (bfd *abfd, bfd_vma vma)
1050 abfd->start_address = vma;
1059 unsigned int bfd_get_gp_size (bfd *abfd);
1062 Return the maximum size of objects to be optimized using the GP
1063 register under MIPS ECOFF. This is typically set by the <<-G>>
1064 argument to the compiler, assembler or linker.
1068 bfd_get_gp_size (bfd *abfd)
1070 if (abfd->format == bfd_object)
1072 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1073 return ecoff_data (abfd)->gp_size;
1074 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1075 return elf_gp_size (abfd);
1085 void bfd_set_gp_size (bfd *abfd, unsigned int i);
1088 Set the maximum size of objects to be optimized using the GP
1089 register under ECOFF or MIPS ELF. This is typically set by
1090 the <<-G>> argument to the compiler, assembler or linker.
1094 bfd_set_gp_size (bfd *abfd, unsigned int i)
1096 /* Don't try to set GP size on an archive or core file! */
1097 if (abfd->format != bfd_object)
1100 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1101 ecoff_data (abfd)->gp_size = i;
1102 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1103 elf_gp_size (abfd) = i;
1106 /* Get the GP value. This is an internal function used by some of the
1107 relocation special_function routines on targets which support a GP
1111 _bfd_get_gp_value (bfd *abfd)
1115 if (abfd->format != bfd_object)
1118 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1119 return ecoff_data (abfd)->gp;
1120 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1121 return elf_gp (abfd);
1126 /* Set the GP value. */
1129 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
1133 if (abfd->format != bfd_object)
1136 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1137 ecoff_data (abfd)->gp = v;
1138 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1147 bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
1150 Convert, like <<strtoul>>, a numerical expression
1151 @var{string} into a <<bfd_vma>> integer, and return that integer.
1152 (Though without as many bells and whistles as <<strtoul>>.)
1153 The expression is assumed to be unsigned (i.e., positive).
1154 If given a @var{base}, it is used as the base for conversion.
1155 A base of 0 causes the function to interpret the string
1156 in hex if a leading "0x" or "0X" is found, otherwise
1157 in octal if a leading zero is found, otherwise in decimal.
1159 If the value would overflow, the maximum <<bfd_vma>> value is
1164 bfd_scan_vma (const char *string, const char **end, int base)
1168 unsigned int cutlim;
1171 /* Let the host do it if possible. */
1172 if (sizeof (bfd_vma) <= sizeof (unsigned long))
1173 return strtoul (string, (char **) end, base);
1175 #ifdef HAVE_STRTOULL
1176 if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1177 return strtoull (string, (char **) end, base);
1182 if (string[0] == '0')
1184 if ((string[1] == 'x') || (string[1] == 'X'))
1191 if ((base < 2) || (base > 36))
1196 && (string[1] == 'x' || string[1] == 'X')
1197 && ISXDIGIT (string[2]))
1202 cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1203 cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1211 if (ISDIGIT (digit))
1212 digit = digit - '0';
1213 else if (ISALPHA (digit))
1214 digit = TOUPPER (digit) - 'A' + 10;
1217 if (digit >= (unsigned int) base)
1219 if (value > cutoff || (value == cutoff && digit > cutlim))
1221 value = value * base + digit;
1226 value = ~ (bfd_vma) 0;
1236 bfd_copy_private_header_data
1239 bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1242 Copy private BFD header information from the BFD @var{ibfd} to the
1243 the BFD @var{obfd}. This copies information that may require
1244 sections to exist, but does not require symbol tables. Return
1245 <<true>> on success, <<false>> on error.
1246 Possible error returns are:
1248 o <<bfd_error_no_memory>> -
1249 Not enough memory exists to create private data for @var{obfd}.
1251 .#define bfd_copy_private_header_data(ibfd, obfd) \
1252 . BFD_SEND (obfd, _bfd_copy_private_header_data, \
1259 bfd_copy_private_bfd_data
1262 bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1265 Copy private BFD information from the BFD @var{ibfd} to the
1266 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error.
1267 Possible error returns are:
1269 o <<bfd_error_no_memory>> -
1270 Not enough memory exists to create private data for @var{obfd}.
1272 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1273 . BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1280 bfd_merge_private_bfd_data
1283 bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
1286 Merge private BFD information from the BFD @var{ibfd} to the
1287 the output file BFD @var{obfd} when linking. Return <<TRUE>>
1288 on success, <<FALSE>> on error. Possible error returns are:
1290 o <<bfd_error_no_memory>> -
1291 Not enough memory exists to create private data for @var{obfd}.
1293 .#define bfd_merge_private_bfd_data(ibfd, obfd) \
1294 . BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1301 bfd_set_private_flags
1304 bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1307 Set private BFD flag information in the BFD @var{abfd}.
1308 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
1311 o <<bfd_error_no_memory>> -
1312 Not enough memory exists to create private data for @var{obfd}.
1314 .#define bfd_set_private_flags(abfd, flags) \
1315 . BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1324 The following functions exist but have not yet been documented.
1326 .#define bfd_sizeof_headers(abfd, info) \
1327 . BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
1329 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1330 . BFD_SEND (abfd, _bfd_find_nearest_line, \
1331 . (abfd, sec, syms, off, file, func, line))
1333 .#define bfd_find_line(abfd, syms, sym, file, line) \
1334 . BFD_SEND (abfd, _bfd_find_line, \
1335 . (abfd, syms, sym, file, line))
1337 .#define bfd_find_inliner_info(abfd, file, func, line) \
1338 . BFD_SEND (abfd, _bfd_find_inliner_info, \
1339 . (abfd, file, func, line))
1341 .#define bfd_debug_info_start(abfd) \
1342 . BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1344 .#define bfd_debug_info_end(abfd) \
1345 . BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1347 .#define bfd_debug_info_accumulate(abfd, section) \
1348 . BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1350 .#define bfd_stat_arch_elt(abfd, stat) \
1351 . BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1353 .#define bfd_update_armap_timestamp(abfd) \
1354 . BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1356 .#define bfd_set_arch_mach(abfd, arch, mach)\
1357 . BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1359 .#define bfd_relax_section(abfd, section, link_info, again) \
1360 . BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1362 .#define bfd_gc_sections(abfd, link_info) \
1363 . BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1365 .#define bfd_merge_sections(abfd, link_info) \
1366 . BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1368 .#define bfd_is_group_section(abfd, sec) \
1369 . BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1371 .#define bfd_discard_group(abfd, sec) \
1372 . BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1374 .#define bfd_link_hash_table_create(abfd) \
1375 . BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1377 .#define bfd_link_hash_table_free(abfd, hash) \
1378 . BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
1380 .#define bfd_link_add_symbols(abfd, info) \
1381 . BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1383 .#define bfd_link_just_syms(abfd, sec, info) \
1384 . BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1386 .#define bfd_final_link(abfd, info) \
1387 . BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1389 .#define bfd_free_cached_info(abfd) \
1390 . BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1392 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1393 . BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1395 .#define bfd_print_private_bfd_data(abfd, file)\
1396 . BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1398 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1399 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1401 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1402 . BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1403 . dyncount, dynsyms, ret))
1405 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1406 . BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1408 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1409 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1411 .extern bfd_byte *bfd_get_relocated_section_contents
1412 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1413 . bfd_boolean, asymbol **);
1419 bfd_get_relocated_section_contents (bfd *abfd,
1420 struct bfd_link_info *link_info,
1421 struct bfd_link_order *link_order,
1423 bfd_boolean relocatable,
1427 bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1428 bfd_byte *, bfd_boolean, asymbol **);
1430 if (link_order->type == bfd_indirect_link_order)
1432 abfd2 = link_order->u.indirect.section->owner;
1439 fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1441 return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1444 /* Record information about an ELF program header. */
1447 bfd_record_phdr (bfd *abfd,
1449 bfd_boolean flags_valid,
1451 bfd_boolean at_valid,
1453 bfd_boolean includes_filehdr,
1454 bfd_boolean includes_phdrs,
1458 struct elf_segment_map *m, **pm;
1461 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1464 amt = sizeof (struct elf_segment_map);
1465 amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1466 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
1473 m->p_flags_valid = flags_valid;
1474 m->p_paddr_valid = at_valid;
1475 m->includes_filehdr = includes_filehdr;
1476 m->includes_phdrs = includes_phdrs;
1479 memcpy (m->sections, secs, count * sizeof (asection *));
1481 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
1489 /* Return true iff this target is 32-bit. */
1494 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1496 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1497 return bed->s->elfclass == ELFCLASS32;
1500 /* For non-ELF targets, use architecture information. */
1501 return bfd_arch_bits_per_address (abfd) <= 32;
1505 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
1506 target's address size. */
1509 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
1514 sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
1518 sprintf_vma (buf, value);
1522 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
1527 fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
1531 fprintf_vma ((FILE *) stream, value);
1539 bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
1543 When more than one machine code number is available for the
1544 same machine type, this function can be used to switch between
1545 the preferred one (alternative == 0) and any others. Currently,
1546 only ELF supports this feature, with up to two alternate
1551 bfd_alt_mach_code (bfd *abfd, int alternative)
1553 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1557 switch (alternative)
1560 code = get_elf_backend_data (abfd)->elf_machine_code;
1564 code = get_elf_backend_data (abfd)->elf_machine_alt1;
1570 code = get_elf_backend_data (abfd)->elf_machine_alt2;
1579 elf_elfheader (abfd)->e_machine = code;
1590 .struct bfd_preserve
1595 . const struct bfd_arch_info *arch_info;
1596 . struct bfd_section *sections;
1597 . struct bfd_section *section_last;
1598 . unsigned int section_count;
1599 . struct bfd_hash_table section_htab;
1609 bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);
1612 When testing an object for compatibility with a particular
1613 target back-end, the back-end object_p function needs to set
1614 up certain fields in the bfd on successfully recognizing the
1615 object. This typically happens in a piecemeal fashion, with
1616 failures possible at many points. On failure, the bfd is
1617 supposed to be restored to its initial state, which is
1618 virtually impossible. However, restoring a subset of the bfd
1619 state works in practice. This function stores the subset and
1620 reinitializes the bfd.
1625 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
1627 preserve->tdata = abfd->tdata.any;
1628 preserve->arch_info = abfd->arch_info;
1629 preserve->flags = abfd->flags;
1630 preserve->sections = abfd->sections;
1631 preserve->section_last = abfd->section_last;
1632 preserve->section_count = abfd->section_count;
1633 preserve->section_htab = abfd->section_htab;
1635 if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
1636 sizeof (struct section_hash_entry)))
1639 abfd->tdata.any = NULL;
1640 abfd->arch_info = &bfd_default_arch_struct;
1641 abfd->flags &= BFD_FLAGS_SAVED;
1642 abfd->sections = NULL;
1643 abfd->section_last = NULL;
1644 abfd->section_count = 0;
1651 bfd_preserve_restore
1654 void bfd_preserve_restore (bfd *, struct bfd_preserve *);
1657 This function restores bfd state saved by bfd_preserve_save.
1658 If MARKER is non-NULL in struct bfd_preserve then that block
1659 and all subsequently bfd_alloc'd memory is freed.
1664 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
1666 bfd_hash_table_free (&abfd->section_htab);
1668 abfd->tdata.any = preserve->tdata;
1669 abfd->arch_info = preserve->arch_info;
1670 abfd->flags = preserve->flags;
1671 abfd->section_htab = preserve->section_htab;
1672 abfd->sections = preserve->sections;
1673 abfd->section_last = preserve->section_last;
1674 abfd->section_count = preserve->section_count;
1676 /* bfd_release frees all memory more recently bfd_alloc'd than
1677 its arg, as well as its arg. */
1678 if (preserve->marker != NULL)
1680 bfd_release (abfd, preserve->marker);
1681 preserve->marker = NULL;
1690 void bfd_preserve_finish (bfd *, struct bfd_preserve *);
1693 This function should be called when the bfd state saved by
1694 bfd_preserve_save is no longer needed. ie. when the back-end
1695 object_p function returns with success.
1700 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
1702 /* It would be nice to be able to free more memory here, eg. old
1703 tdata, but that's not possible since these blocks are sitting
1704 inside bfd_alloc'd memory. The section hash is on a separate
1706 bfd_hash_table_free (&preserve->section_htab);
1711 bfd_emul_get_maxpagesize
1714 bfd_vma bfd_emul_get_maxpagesize (const char *);
1717 Returns the maximum page size, in bytes, as determined by
1721 Returns the maximum page size in bytes for ELF, 0 otherwise.
1725 bfd_emul_get_maxpagesize (const char *emul)
1727 const bfd_target *target;
1729 target = bfd_find_target (emul, NULL);
1731 && target->flavour == bfd_target_elf_flavour)
1732 return xvec_get_elf_backend_data (target)->maxpagesize;
1738 bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size,
1739 int offset, const bfd_target *orig_target)
1741 if (target->flavour == bfd_target_elf_flavour)
1743 const struct elf_backend_data *bed;
1745 bed = xvec_get_elf_backend_data (target);
1746 *((bfd_vma *) ((char *) bed + offset)) = size;
1749 if (target->alternative_target
1750 && target->alternative_target != orig_target)
1751 bfd_elf_set_pagesize (target->alternative_target, size, offset,
1757 bfd_emul_set_maxpagesize
1760 void bfd_emul_set_maxpagesize (const char *, bfd_vma);
1763 For ELF, set the maximum page size for the emulation. It is
1764 a no-op for other formats.
1769 bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
1771 const bfd_target *target;
1773 target = bfd_find_target (emul, NULL);
1775 bfd_elf_set_pagesize (target, size,
1776 offsetof (struct elf_backend_data,
1777 maxpagesize), target);
1782 bfd_emul_get_commonpagesize
1785 bfd_vma bfd_emul_get_commonpagesize (const char *);
1788 Returns the common page size, in bytes, as determined by
1792 Returns the common page size in bytes for ELF, 0 otherwise.
1796 bfd_emul_get_commonpagesize (const char *emul)
1798 const bfd_target *target;
1800 target = bfd_find_target (emul, NULL);
1802 && target->flavour == bfd_target_elf_flavour)
1803 return xvec_get_elf_backend_data (target)->commonpagesize;
1810 bfd_emul_set_commonpagesize
1813 void bfd_emul_set_commonpagesize (const char *, bfd_vma);
1816 For ELF, set the common page size for the emulation. It is
1817 a no-op for other formats.
1822 bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)
1824 const bfd_target *target;
1826 target = bfd_find_target (emul, NULL);
1828 bfd_elf_set_pagesize (target, size,
1829 offsetof (struct elf_backend_data,
1830 commonpagesize), target);
1838 char *bfd_demangle (bfd *, const char *, int);
1841 Wrapper around cplus_demangle. Strips leading underscores and
1842 other such chars that would otherwise confuse the demangler.
1843 If passed a g++ v3 ABI mangled name, returns a buffer allocated
1844 with malloc holding the demangled name. Returns NULL otherwise
1845 and on memory alloc failure.
1849 bfd_demangle (bfd *abfd, const char *name, int options)
1852 const char *pre, *suf;
1854 bfd_boolean skip_lead;
1856 skip_lead = (abfd != NULL
1858 && bfd_get_symbol_leading_char (abfd) == *name);
1862 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
1863 or the MS PE format. These formats have a number of leading '.'s
1864 on at least some symbols, so we remove all dots to avoid
1865 confusing the demangler. */
1867 while (*name == '.' || *name == '$')
1869 pre_len = name - pre;
1871 /* Strip off @plt and suchlike too. */
1873 suf = strchr (name, '@');
1876 alloc = (char *) bfd_malloc (suf - name + 1);
1879 memcpy (alloc, name, suf - name);
1880 alloc[suf - name] = '\0';
1884 res = cplus_demangle (name, options);
1893 size_t len = strlen (pre) + 1;
1894 alloc = (char *) bfd_malloc (len);
1897 memcpy (alloc, pre, len);
1903 /* Put back any prefix or suffix. */
1904 if (pre_len != 0 || suf != NULL)
1913 suf_len = strlen (suf) + 1;
1914 final = (char *) bfd_malloc (pre_len + len + suf_len);
1917 memcpy (final, pre, pre_len);
1918 memcpy (final + pre_len, res, len);
1919 memcpy (final + pre_len + len, suf, suf_len);