1 /* Generic BFD library interface and support routines.
2 Copyright (C) 1990-2019 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.
43 . write_direction = 2,
47 .enum bfd_plugin_format
49 . bfd_plugin_unknown = 0,
62 . {* The filename the application opened the BFD with. *}
63 . const char *filename;
65 . {* A pointer to the target jump table. *}
66 . const struct bfd_target *xvec;
68 . {* The IOSTREAM, and corresponding IO vector that provide access
69 . to the file backing the BFD. *}
71 . const struct bfd_iovec *iovec;
73 . {* The caching routines use these to maintain a
74 . least-recently-used list of BFDs. *}
75 . struct bfd *lru_prev, *lru_next;
77 . {* Track current file position (or current buffer offset for
78 . in-memory BFDs). When a file is closed by the caching routines,
79 . BFD retains state information on the file here. *}
82 . {* File modified time, if mtime_set is TRUE. *}
85 . {* A unique identifier of the BFD *}
88 . {* The format which belongs to the BFD. (object, core, etc.) *}
89 . ENUM_BITFIELD (bfd_format) format : 3;
91 . {* The direction with which the BFD was opened. *}
92 . ENUM_BITFIELD (bfd_direction) direction : 2;
94 . {* Format_specific flags. *}
95 . flagword flags : 20;
97 . {* Values that may appear in the flags field of a BFD. These also
98 . appear in the object_flags field of the bfd_target structure, where
99 . they indicate the set of flags used by that backend (not all flags
100 . are meaningful for all object file formats) (FIXME: at the moment,
101 . the object_flags values have mostly just been copied from backend
102 . to another, and are not necessarily correct). *}
104 .#define BFD_NO_FLAGS 0x0
106 . {* BFD contains relocation entries. *}
107 .#define HAS_RELOC 0x1
109 . {* BFD is directly executable. *}
112 . {* BFD has line number information (basically used for F_LNNO in a
114 .#define HAS_LINENO 0x4
116 . {* BFD has debugging information. *}
117 .#define HAS_DEBUG 0x08
119 . {* BFD has symbols. *}
120 .#define HAS_SYMS 0x10
122 . {* BFD has local symbols (basically used for F_LSYMS in a COFF
124 .#define HAS_LOCALS 0x20
126 . {* BFD is a dynamic object. *}
127 .#define DYNAMIC 0x40
129 . {* Text section is write protected (if D_PAGED is not set, this is
130 . like an a.out NMAGIC file) (the linker sets this by default, but
131 . clears it for -r or -N). *}
132 .#define WP_TEXT 0x80
134 . {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
135 . linker sets this by default, but clears it for -r or -n or -N). *}
136 .#define D_PAGED 0x100
138 . {* BFD is relaxable (this means that bfd_relax_section may be able to
139 . do something) (sometimes bfd_relax_section can do something even if
140 . this is not set). *}
141 .#define BFD_IS_RELAXABLE 0x200
143 . {* This may be set before writing out a BFD to request using a
144 . traditional format. For example, this is used to request that when
145 . writing out an a.out object the symbols not be hashed to eliminate
147 .#define BFD_TRADITIONAL_FORMAT 0x400
149 . {* This flag indicates that the BFD contents are actually cached
150 . in memory. If this is set, iostream points to a bfd_in_memory
152 .#define BFD_IN_MEMORY 0x800
154 . {* This BFD has been created by the linker and doesn't correspond
155 . to any input file. *}
156 .#define BFD_LINKER_CREATED 0x1000
158 . {* This may be set before writing out a BFD to request that it
159 . be written using values for UIDs, GIDs, timestamps, etc. that
160 . will be consistent from run to run. *}
161 .#define BFD_DETERMINISTIC_OUTPUT 0x2000
163 . {* Compress sections in this BFD. *}
164 .#define BFD_COMPRESS 0x4000
166 . {* Decompress sections in this BFD. *}
167 .#define BFD_DECOMPRESS 0x8000
169 . {* BFD is a dummy, for plugins. *}
170 .#define BFD_PLUGIN 0x10000
172 . {* Compress sections in this BFD with SHF_COMPRESSED from gABI. *}
173 .#define BFD_COMPRESS_GABI 0x20000
175 . {* Convert ELF common symbol type to STT_COMMON or STT_OBJECT in this
177 .#define BFD_CONVERT_ELF_COMMON 0x40000
179 . {* Use the ELF STT_COMMON type in this BFD. *}
180 .#define BFD_USE_ELF_STT_COMMON 0x80000
182 . {* Flags bits to be saved in bfd_preserve_save. *}
183 .#define BFD_FLAGS_SAVED \
184 . (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
185 . | BFD_PLUGIN | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON \
186 . | BFD_USE_ELF_STT_COMMON)
188 . {* Flags bits which are for BFD use only. *}
189 .#define BFD_FLAGS_FOR_BFD_USE_MASK \
190 . (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
191 . | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT \
192 . | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON)
194 . {* Is the file descriptor being cached? That is, can it be closed as
195 . needed, and re-opened when accessed later? *}
196 . unsigned int cacheable : 1;
198 . {* Marks whether there was a default target specified when the
199 . BFD was opened. This is used to select which matching algorithm
200 . to use to choose the back end. *}
201 . unsigned int target_defaulted : 1;
203 . {* ... and here: (``once'' means at least once). *}
204 . unsigned int opened_once : 1;
206 . {* Set if we have a locally maintained mtime value, rather than
207 . getting it from the file each time. *}
208 . unsigned int mtime_set : 1;
210 . {* Flag set if symbols from this BFD should not be exported. *}
211 . unsigned int no_export : 1;
213 . {* Remember when output has begun, to stop strange things
215 . unsigned int output_has_begun : 1;
217 . {* Have archive map. *}
218 . unsigned int has_armap : 1;
220 . {* Set if this is a thin archive. *}
221 . unsigned int is_thin_archive : 1;
223 . {* Set if only required symbols should be added in the link hash table for
224 . this object. Used by VMS linkers. *}
225 . unsigned int selective_search : 1;
227 . {* Set if this is the linker output BFD. *}
228 . unsigned int is_linker_output : 1;
230 . {* Set if this is the linker input BFD. *}
231 . unsigned int is_linker_input : 1;
233 . {* If this is an input for a compiler plug-in library. *}
234 . ENUM_BITFIELD (bfd_plugin_format) plugin_format : 2;
236 . {* Set if this is a plugin output file. *}
237 . unsigned int lto_output : 1;
239 . {* Set if this is a slim LTO object not loaded with a compiler plugin. *}
240 . unsigned int lto_slim_object : 1;
242 . {* Set to dummy BFD created when claimed by a compiler plug-in
244 . bfd *plugin_dummy_bfd;
246 . {* Currently my_archive is tested before adding origin to
247 . anything. I believe that this can become always an add of
248 . origin, with origin set to 0 for non archive files. *}
251 . {* The origin in the archive of the proxy entry. This will
252 . normally be the same as origin, except for thin archives,
253 . when it will contain the current offset of the proxy in the
254 . thin archive rather than the offset of the bfd in its actual
256 . ufile_ptr proxy_origin;
258 . {* A hash table for section names. *}
259 . struct bfd_hash_table section_htab;
261 . {* Pointer to linked list of sections. *}
262 . struct bfd_section *sections;
264 . {* The last section on the section list. *}
265 . struct bfd_section *section_last;
267 . {* The number of sections. *}
268 . unsigned int section_count;
270 . {* A field used by _bfd_generic_link_add_archive_symbols. This will
271 . be used only for archive elements. *}
274 . {* Stuff only useful for object files:
275 . The start address. *}
276 . bfd_vma start_address;
278 . {* Symbol table for output BFD (with symcount entries).
279 . Also used by the linker to cache input BFD symbols. *}
280 . struct bfd_symbol **outsymbols;
282 . {* Used for input and output. *}
283 . unsigned int symcount;
285 . {* Used for slurped dynamic symbol tables. *}
286 . unsigned int dynsymcount;
288 . {* Pointer to structure which contains architecture information. *}
289 . const struct bfd_arch_info *arch_info;
291 . {* Stuff only useful for archives. *}
293 . struct bfd *my_archive; {* The containing archive BFD. *}
294 . struct bfd *archive_next; {* The next BFD in the archive. *}
295 . struct bfd *archive_head; {* The first BFD in the archive. *}
296 . struct bfd *nested_archives; {* List of nested archive in a flattened
300 . {* For input BFDs, a chain of BFDs involved in a link. *}
302 . {* For output BFD, the linker hash table. *}
303 . struct bfd_link_hash_table *hash;
306 . {* Used by the back end to hold private data. *}
309 . struct aout_data_struct *aout_data;
310 . struct artdata *aout_ar_data;
311 . struct coff_tdata *coff_obj_data;
312 . struct pe_tdata *pe_obj_data;
313 . struct xcoff_tdata *xcoff_obj_data;
314 . struct ecoff_tdata *ecoff_obj_data;
315 . struct srec_data_struct *srec_data;
316 . struct verilog_data_struct *verilog_data;
317 . struct ihex_data_struct *ihex_data;
318 . struct tekhex_data_struct *tekhex_data;
319 . struct elf_obj_tdata *elf_obj_data;
320 . struct mmo_data_struct *mmo_data;
321 . struct sun_core_struct *sun_core_data;
322 . struct sco5_core_struct *sco5_core_data;
323 . struct trad_core_struct *trad_core_data;
324 . struct som_data_struct *som_data;
325 . struct hpux_core_struct *hpux_core_data;
326 . struct hppabsd_core_struct *hppabsd_core_data;
327 . struct sgi_core_struct *sgi_core_data;
328 . struct lynx_core_struct *lynx_core_data;
329 . struct osf_core_struct *osf_core_data;
330 . struct cisco_core_struct *cisco_core_data;
331 . struct versados_data_struct *versados_data;
332 . struct netbsd_core_struct *netbsd_core_data;
333 . struct mach_o_data_struct *mach_o_data;
334 . struct mach_o_fat_data_struct *mach_o_fat_data;
335 . struct plugin_data_struct *plugin_data;
336 . struct bfd_pef_data_struct *pef_data;
337 . struct bfd_pef_xlib_data_struct *pef_xlib_data;
338 . struct bfd_sym_data_struct *sym_data;
343 . {* Used by the application to hold private data. *}
346 . {* Where all the allocated stuff under this BFD goes. This is a
347 . struct objalloc *, but we use void * to avoid requiring the inclusion
351 . {* For input BFDs, the build ID, if the object has one. *}
352 . const struct bfd_build_id *build_id;
355 .{* See note beside bfd_set_section_userdata. *}
356 .static inline bfd_boolean
357 .bfd_set_cacheable (bfd * abfd, bfd_boolean val)
359 . abfd->cacheable = val;
369 #include "libiberty.h"
370 #include "demangle.h"
371 #include "safe-ctype.h"
374 #include "coff/internal.h"
375 #include "coff/sym.h"
377 #include "libecoff.h"
382 #define EXIT_FAILURE 1
386 /* provide storage for subsystem, stack and heap data which may have been
387 passed in on the command line. Ld puts this data into a bfd_link_info
388 struct which ultimately gets passed in to the bfd. When it arrives, copy
389 it to the following struct so that the data will be available in coffcode.h
390 where it is needed. The typedef's used are defined in bfd.h */
394 Error reporting, Miscellaneous, typedef bfd, BFD front end
399 Most BFD functions return nonzero on success (check their
400 individual documentation for precise semantics). On an error,
401 they call <<bfd_set_error>> to set an error condition that callers
402 can check by calling <<bfd_get_error>>.
403 If that returns <<bfd_error_system_call>>, then check
406 The easiest way to report a BFD error to the user is to
410 Type <<bfd_error_type>>
412 The values returned by <<bfd_get_error>> are defined by the
413 enumerated type <<bfd_error_type>>.
417 .typedef enum bfd_error
419 . bfd_error_no_error = 0,
420 . bfd_error_system_call,
421 . bfd_error_invalid_target,
422 . bfd_error_wrong_format,
423 . bfd_error_wrong_object_format,
424 . bfd_error_invalid_operation,
425 . bfd_error_no_memory,
426 . bfd_error_no_symbols,
427 . bfd_error_no_armap,
428 . bfd_error_no_more_archived_files,
429 . bfd_error_malformed_archive,
430 . bfd_error_missing_dso,
431 . bfd_error_file_not_recognized,
432 . bfd_error_file_ambiguously_recognized,
433 . bfd_error_no_contents,
434 . bfd_error_nonrepresentable_section,
435 . bfd_error_no_debug_section,
436 . bfd_error_bad_value,
437 . bfd_error_file_truncated,
438 . bfd_error_file_too_big,
439 . bfd_error_on_input,
440 . bfd_error_invalid_error_code
446 static bfd_error_type bfd_error = bfd_error_no_error;
447 static bfd *input_bfd = NULL;
448 static bfd_error_type input_error = bfd_error_no_error;
450 const char *const bfd_errmsgs[] =
453 N_("system call error"),
454 N_("invalid bfd target"),
455 N_("file in wrong format"),
456 N_("archive object file in wrong format"),
457 N_("invalid operation"),
458 N_("memory exhausted"),
460 N_("archive has no index; run ranlib to add one"),
461 N_("no more archived files"),
462 N_("malformed archive"),
463 N_("DSO missing from command line"),
464 N_("file format not recognized"),
465 N_("file format is ambiguous"),
466 N_("section has no contents"),
467 N_("nonrepresentable section on output"),
468 N_("symbol needs debug section which does not exist"),
470 N_("file truncated"),
472 N_("error reading %s: %s"),
473 N_("#<invalid error code>")
481 bfd_error_type bfd_get_error (void);
484 Return the current BFD error condition.
498 void bfd_set_error (bfd_error_type error_tag);
501 Set the BFD error condition to be @var{error_tag}.
503 @var{error_tag} must not be bfd_error_on_input. Use
504 bfd_set_input_error for input errors instead.
508 bfd_set_error (bfd_error_type error_tag)
510 bfd_error = error_tag;
511 if (bfd_error >= bfd_error_on_input)
520 void bfd_set_input_error (bfd *input, bfd_error_type error_tag);
524 Set the BFD error condition to be bfd_error_on_input.
525 @var{input} is the input bfd where the error occurred, and
526 @var{error_tag} the bfd_error_type error.
530 bfd_set_input_error (bfd *input, bfd_error_type error_tag)
532 /* This is an error that occurred during bfd_close when writing an
533 archive, but on one of the input files. */
534 bfd_error = bfd_error_on_input;
536 input_error = error_tag;
537 if (input_error >= bfd_error_on_input)
546 const char *bfd_errmsg (bfd_error_type error_tag);
549 Return a string describing the error @var{error_tag}, or
550 the system error if @var{error_tag} is <<bfd_error_system_call>>.
554 bfd_errmsg (bfd_error_type error_tag)
559 if (error_tag == bfd_error_on_input)
562 const char *msg = bfd_errmsg (input_error);
564 if (asprintf (&buf, _(bfd_errmsgs [error_tag]), input_bfd->filename, msg)
568 /* Ick, what to do on out of memory? */
572 if (error_tag == bfd_error_system_call)
573 return xstrerror (errno);
575 if (error_tag > bfd_error_invalid_error_code)
576 error_tag = bfd_error_invalid_error_code; /* sanity check */
578 return _(bfd_errmsgs [error_tag]);
586 void bfd_perror (const char *message);
589 Print to the standard error stream a string describing the
590 last BFD error that occurred, or the last system error if
591 the last BFD error was a system call failure. If @var{message}
592 is non-NULL and non-empty, the error string printed is preceded
593 by @var{message}, a colon, and a space. It is followed by a newline.
597 bfd_perror (const char *message)
600 if (message == NULL || *message == '\0')
601 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
603 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
611 Some BFD functions want to print messages describing the
612 problem. They call a BFD error handler function. This
613 function may be overridden by the program.
615 The BFD error handler acts like vprintf.
619 .typedef void (*bfd_error_handler_type) (const char *, va_list);
623 /* The program name used when printing BFD error messages. */
625 static const char *_bfd_error_program_name;
627 /* Support for positional parameters. */
629 union _bfd_doprnt_args
649 /* This macro and _bfd_doprnt taken from libiberty _doprnt.c, tidied a
650 little and extended to handle '%pA', '%pB' and positional parameters. */
652 #define PRINT_TYPE(TYPE, FIELD) \
655 TYPE value = (TYPE) args[arg_no].FIELD; \
656 result = fprintf (stream, specifier, value); \
660 _bfd_doprnt (FILE *stream, const char *format, union _bfd_doprnt_args *args)
662 const char *ptr = format;
664 int total_printed = 0;
665 unsigned int arg_count = 0;
673 /* While we have regular characters, print them. */
674 char *end = strchr (ptr, '%');
676 result = fprintf (stream, "%.*s", (int) (end - ptr), ptr);
678 result = fprintf (stream, "%s", ptr);
681 else if (ptr[1] == '%')
689 /* We have a format specifier! */
690 char *sptr = specifier;
691 int wide_width = 0, short_width = 0;
694 /* Copy the % and move forward. */
697 /* Check for a positional parameter. */
699 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
705 /* Move past flags. */
706 while (strchr ("-+ #0'I", *ptr))
712 unsigned int arg_index;
715 arg_index = arg_count;
716 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
718 arg_index = *ptr - '1';
721 value = abs (args[arg_index].i);
723 sptr += sprintf (sptr, "%d", value);
726 /* Handle explicit numeric value. */
727 while (ISDIGIT (*ptr))
733 /* Copy and go past the period. */
738 unsigned int arg_index;
741 arg_index = arg_count;
742 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
744 arg_index = *ptr - '1';
747 value = abs (args[arg_index].i);
749 sptr += sprintf (sptr, "%d", value);
752 /* Handle explicit numeric value. */
753 while (ISDIGIT (*ptr))
756 while (strchr ("hlL", *ptr))
775 /* Copy the type specifier, and NULL terminate. */
778 if ((int) arg_no < 0)
791 /* Short values are promoted to int, so just copy it
792 as an int and trust the C library printf to cast it
793 to the right width. */
804 PRINT_TYPE (long, l);
808 #if defined (__MSVCRT__)
815 #if defined (__GNUC__) || defined (HAVE_LONG_LONG)
816 PRINT_TYPE (long long, ll);
818 /* Fake it and hope for the best. */
819 PRINT_TYPE (long, l);
833 PRINT_TYPE (double, d);
836 #if defined (__GNUC__) || defined (HAVE_LONG_DOUBLE)
837 PRINT_TYPE (long double, ld);
839 /* Fake it and hope for the best. */
840 PRINT_TYPE (double, d);
846 PRINT_TYPE (char *, p);
853 const char *group = NULL;
854 struct coff_comdat_info *ci;
857 sec = (asection *) args[arg_no].p;
859 /* Invoking %pA with a null section pointer is an
864 && bfd_get_flavour (abfd) == bfd_target_elf_flavour
865 && elf_next_in_group (sec) != NULL
866 && (sec->flags & SEC_GROUP) == 0)
867 group = elf_group_name (sec);
868 else if (abfd != NULL
869 && bfd_get_flavour (abfd) == bfd_target_coff_flavour
870 && (ci = bfd_coff_get_comdat_section (sec->owner,
874 result = fprintf (stream, "%s[%s]", sec->name, group);
876 result = fprintf (stream, "%s", sec->name);
878 else if (*ptr == 'B')
883 abfd = (bfd *) args[arg_no].p;
885 /* Invoking %pB with a null bfd pointer is an
888 else if (abfd->my_archive
889 && !bfd_is_thin_archive (abfd->my_archive))
890 result = fprintf (stream, "%s(%s)",
891 abfd->my_archive->filename,
894 result = fprintf (stream, "%s", abfd->filename);
897 PRINT_TYPE (void *, p);
906 total_printed += result;
909 return total_printed;
912 /* First pass over FORMAT to gather ARGS. Returns number of args. */
915 _bfd_doprnt_scan (const char *format, union _bfd_doprnt_args *args)
917 const char *ptr = format;
918 unsigned int arg_count = 0;
924 ptr = strchr (ptr, '%');
928 else if (ptr[1] == '%')
932 int wide_width = 0, short_width = 0;
938 /* Check for a positional parameter. */
940 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
946 /* Move past flags. */
947 while (strchr ("-+ #0'I", *ptr))
952 unsigned int arg_index;
955 arg_index = arg_count;
956 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
958 arg_index = *ptr - '1';
963 args[arg_index].type = Int;
967 /* Handle explicit numeric value. */
968 while (ISDIGIT (*ptr))
977 unsigned int arg_index;
980 arg_index = arg_count;
981 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
983 arg_index = *ptr - '1';
988 args[arg_index].type = Int;
992 /* Handle explicit numeric value. */
993 while (ISDIGIT (*ptr))
996 while (strchr ("hlL", *ptr))
1016 if ((int) arg_no < 0)
1044 #if defined (__GNUC__) || defined (HAVE_LONG_LONG)
1045 arg_type = LongLong;
1060 if (wide_width == 0)
1064 #if defined (__GNUC__) || defined (HAVE_LONG_DOUBLE)
1065 arg_type = LongDouble;
1076 if (*ptr == 'A' || *ptr == 'B')
1086 args[arg_no].type = arg_type;
1095 error_handler_internal (const char *fmt, va_list ap)
1097 unsigned int i, arg_count;
1098 union _bfd_doprnt_args args[9];
1100 for (i = 0; i < sizeof (args) / sizeof (args[0]); i++)
1103 arg_count = _bfd_doprnt_scan (fmt, args);
1104 for (i = 0; i < arg_count; i++)
1106 switch (args[i].type)
1109 args[i].i = va_arg (ap, int);
1112 args[i].l = va_arg (ap, long);
1115 args[i].ll = va_arg (ap, long long);
1118 args[i].d = va_arg (ap, double);
1121 args[i].ld = va_arg (ap, long double);
1124 args[i].p = va_arg (ap, void *);
1131 /* PR 4992: Don't interrupt output being sent to stdout. */
1134 if (_bfd_error_program_name != NULL)
1135 fprintf (stderr, "%s: ", _bfd_error_program_name);
1137 fprintf (stderr, "BFD: ");
1139 _bfd_doprnt (stderr, fmt, args);
1141 /* On AIX, putc is implemented as a macro that triggers a -Wunused-value
1142 warning, so use the fputc function to avoid it. */
1143 fputc ('\n', stderr);
1147 /* This is a function pointer to the routine which should handle BFD
1148 error messages. It is called when a BFD routine encounters an
1149 error for which it wants to print a message. Going through a
1150 function pointer permits a program linked against BFD to intercept
1151 the messages and deal with them itself. */
1153 static bfd_error_handler_type _bfd_error_internal = error_handler_internal;
1160 void _bfd_error_handler (const char *fmt, ...) ATTRIBUTE_PRINTF_1;
1163 This is the default routine to handle BFD error messages.
1164 Like fprintf (stderr, ...), but also handles some extra format
1167 %pA section name from section. For group components, prints
1169 %pB file name from bfd. For archive components, prints
1172 Beware: Only supports a maximum of 9 format arguments.
1176 _bfd_error_handler (const char *fmt, ...)
1181 _bfd_error_internal (fmt, ap);
1187 bfd_set_error_handler
1190 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
1193 Set the BFD error handler function. Returns the previous
1197 bfd_error_handler_type
1198 bfd_set_error_handler (bfd_error_handler_type pnew)
1200 bfd_error_handler_type pold;
1202 pold = _bfd_error_internal;
1203 _bfd_error_internal = pnew;
1209 bfd_set_error_program_name
1212 void bfd_set_error_program_name (const char *);
1215 Set the program name to use when printing a BFD error. This
1216 is printed before the error message followed by a colon and
1217 space. The string must not be changed after it is passed to
1222 bfd_set_error_program_name (const char *name)
1224 _bfd_error_program_name = name;
1231 If BFD finds an internal inconsistency, the bfd assert
1232 handler is called with information on the BFD version, BFD
1233 source file and line. If this happens, most programs linked
1234 against BFD are expected to want to exit with an error, or mark
1235 the current BFD operation as failed, so it is recommended to
1236 override the default handler, which just calls
1237 _bfd_error_handler and continues.
1241 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg,
1242 . const char *bfd_version,
1243 . const char *bfd_file,
1248 /* Note the use of bfd_ prefix on the parameter names above: we want to
1249 show which one is the message and which is the version by naming the
1250 parameters, but avoid polluting the program-using-bfd namespace as
1251 the typedef is visible in the exported headers that the program
1252 includes. Below, it's just for consistency. */
1255 _bfd_default_assert_handler (const char *bfd_formatmsg,
1256 const char *bfd_version,
1257 const char *bfd_file,
1261 _bfd_error_handler (bfd_formatmsg, bfd_version, bfd_file, bfd_line);
1264 /* Similar to _bfd_error_handler, a program can decide to exit on an
1265 internal BFD error. We use a non-variadic type to simplify passing
1266 on parameters to other functions, e.g. _bfd_error_handler. */
1268 static bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler;
1272 bfd_set_assert_handler
1275 bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type);
1278 Set the BFD assert handler function. Returns the previous
1282 bfd_assert_handler_type
1283 bfd_set_assert_handler (bfd_assert_handler_type pnew)
1285 bfd_assert_handler_type pold;
1287 pold = _bfd_assert_handler;
1288 _bfd_assert_handler = pnew;
1294 Miscellaneous, Memory Usage, Error reporting, BFD front end
1300 Miscellaneous functions
1305 bfd_get_reloc_upper_bound
1308 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
1311 Return the number of bytes required to store the
1312 relocation information associated with section @var{sect}
1313 attached to bfd @var{abfd}. If an error occurs, return -1.
1318 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
1320 if (abfd->format != bfd_object)
1322 bfd_set_error (bfd_error_invalid_operation);
1326 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
1331 bfd_canonicalize_reloc
1334 long bfd_canonicalize_reloc
1335 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
1338 Call the back end associated with the open BFD
1339 @var{abfd} and translate the external form of the relocation
1340 information attached to @var{sec} into the internal canonical
1341 form. Place the table into memory at @var{loc}, which has
1342 been preallocated, usually by a call to
1343 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or
1346 The @var{syms} table is also needed for horrible internal magic
1351 bfd_canonicalize_reloc (bfd *abfd,
1356 if (abfd->format != bfd_object)
1358 bfd_set_error (bfd_error_invalid_operation);
1362 return BFD_SEND (abfd, _bfd_canonicalize_reloc,
1363 (abfd, asect, location, symbols));
1372 (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
1375 Set the relocation pointer and count within
1376 section @var{sec} to the values @var{rel} and @var{count}.
1377 The argument @var{abfd} is ignored.
1379 .#define bfd_set_reloc(abfd, asect, location, count) \
1380 . BFD_SEND (abfd, _bfd_set_reloc, (abfd, asect, location, count))
1388 bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
1391 Set the flag word in the BFD @var{abfd} to the value @var{flags}.
1393 Possible errors are:
1394 o <<bfd_error_wrong_format>> - The target bfd was not of object format.
1395 o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
1396 o <<bfd_error_invalid_operation>> -
1397 The flag word contained a bit which was not applicable to the
1398 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit
1399 on a BFD format which does not support demand paging.
1404 bfd_set_file_flags (bfd *abfd, flagword flags)
1406 if (abfd->format != bfd_object)
1408 bfd_set_error (bfd_error_wrong_format);
1412 if (bfd_read_p (abfd))
1414 bfd_set_error (bfd_error_invalid_operation);
1418 bfd_get_file_flags (abfd) = flags;
1419 if ((flags & bfd_applicable_file_flags (abfd)) != flags)
1421 bfd_set_error (bfd_error_invalid_operation);
1429 bfd_assert (const char *file, int line)
1431 /* xgettext:c-format */
1432 (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"),
1433 BFD_VERSION_STRING, file, line);
1436 /* A more or less friendly abort message. In libbfd.h abort is
1437 defined to call this function. */
1440 _bfd_abort (const char *file, int line, const char *fn)
1444 /* xgettext:c-format */
1445 (_("BFD %s internal error, aborting at %s:%d in %s\n"),
1446 BFD_VERSION_STRING, file, line, fn);
1449 /* xgettext:c-format */
1450 (_("BFD %s internal error, aborting at %s:%d\n"),
1451 BFD_VERSION_STRING, file, line);
1452 _bfd_error_handler (_("Please report this bug.\n"));
1453 _exit (EXIT_FAILURE);
1461 int bfd_get_arch_size (bfd *abfd);
1464 Returns the normalized architecture address size, in bits, as
1465 determined by the object file's format. By normalized, we mean
1466 either 32 or 64. For ELF, this information is included in the
1467 header. Use bfd_arch_bits_per_address for number of bits in
1468 the architecture address.
1471 Returns the arch size in bits if known, <<-1>> otherwise.
1475 bfd_get_arch_size (bfd *abfd)
1477 if (abfd->xvec->flavour == bfd_target_elf_flavour)
1478 return get_elf_backend_data (abfd)->s->arch_size;
1480 return bfd_arch_bits_per_address (abfd) > 32 ? 64 : 32;
1485 bfd_get_sign_extend_vma
1488 int bfd_get_sign_extend_vma (bfd *abfd);
1491 Indicates if the target architecture "naturally" sign extends
1492 an address. Some architectures implicitly sign extend address
1493 values when they are converted to types larger than the size
1494 of an address. For instance, bfd_get_start_address() will
1495 return an address sign extended to fill a bfd_vma when this is
1499 Returns <<1>> if the target architecture is known to sign
1500 extend addresses, <<0>> if the target architecture is known to
1501 not sign extend addresses, and <<-1>> otherwise.
1505 bfd_get_sign_extend_vma (bfd *abfd)
1509 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1510 return get_elf_backend_data (abfd)->sign_extend_vma;
1512 name = bfd_get_target (abfd);
1514 /* Return a proper value for DJGPP & PE COFF.
1515 This function is required for DWARF2 support, but there is
1516 no place to store this information in the COFF back end.
1517 Should enough other COFF targets add support for DWARF2,
1518 a place will have to be found. Until then, this hack will do. */
1519 if (CONST_STRNEQ (name, "coff-go32")
1520 || strcmp (name, "pe-i386") == 0
1521 || strcmp (name, "pei-i386") == 0
1522 || strcmp (name, "pe-x86-64") == 0
1523 || strcmp (name, "pei-x86-64") == 0
1524 || strcmp (name, "pe-arm-wince-little") == 0
1525 || strcmp (name, "pei-arm-wince-little") == 0
1526 || strcmp (name, "aixcoff-rs6000") == 0
1527 || strcmp (name, "aix5coff64-rs6000") == 0)
1530 if (CONST_STRNEQ (name, "mach-o"))
1533 bfd_set_error (bfd_error_wrong_format);
1539 bfd_set_start_address
1542 bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
1545 Make @var{vma} the entry point of output BFD @var{abfd}.
1548 Returns <<TRUE>> on success, <<FALSE>> otherwise.
1552 bfd_set_start_address (bfd *abfd, bfd_vma vma)
1554 abfd->start_address = vma;
1563 unsigned int bfd_get_gp_size (bfd *abfd);
1566 Return the maximum size of objects to be optimized using the GP
1567 register under MIPS ECOFF. This is typically set by the <<-G>>
1568 argument to the compiler, assembler or linker.
1572 bfd_get_gp_size (bfd *abfd)
1574 if (abfd->format == bfd_object)
1576 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1577 return ecoff_data (abfd)->gp_size;
1578 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1579 return elf_gp_size (abfd);
1589 void bfd_set_gp_size (bfd *abfd, unsigned int i);
1592 Set the maximum size of objects to be optimized using the GP
1593 register under ECOFF or MIPS ELF. This is typically set by
1594 the <<-G>> argument to the compiler, assembler or linker.
1598 bfd_set_gp_size (bfd *abfd, unsigned int i)
1600 /* Don't try to set GP size on an archive or core file! */
1601 if (abfd->format != bfd_object)
1604 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1605 ecoff_data (abfd)->gp_size = i;
1606 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1607 elf_gp_size (abfd) = i;
1610 /* Get the GP value. This is an internal function used by some of the
1611 relocation special_function routines on targets which support a GP
1615 _bfd_get_gp_value (bfd *abfd)
1619 if (abfd->format != bfd_object)
1622 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1623 return ecoff_data (abfd)->gp;
1624 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1625 return elf_gp (abfd);
1630 /* Set the GP value. */
1633 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
1637 if (abfd->format != bfd_object)
1640 if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1641 ecoff_data (abfd)->gp = v;
1642 else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1651 bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
1654 Convert, like <<strtoul>>, a numerical expression
1655 @var{string} into a <<bfd_vma>> integer, and return that integer.
1656 (Though without as many bells and whistles as <<strtoul>>.)
1657 The expression is assumed to be unsigned (i.e., positive).
1658 If given a @var{base}, it is used as the base for conversion.
1659 A base of 0 causes the function to interpret the string
1660 in hex if a leading "0x" or "0X" is found, otherwise
1661 in octal if a leading zero is found, otherwise in decimal.
1663 If the value would overflow, the maximum <<bfd_vma>> value is
1668 bfd_scan_vma (const char *string, const char **end, int base)
1672 unsigned int cutlim;
1675 /* Let the host do it if possible. */
1676 if (sizeof (bfd_vma) <= sizeof (unsigned long))
1677 return strtoul (string, (char **) end, base);
1679 #if defined (HAVE_STRTOULL) && defined (HAVE_LONG_LONG)
1680 if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1681 return strtoull (string, (char **) end, base);
1686 if (string[0] == '0')
1688 if ((string[1] == 'x') || (string[1] == 'X'))
1695 if ((base < 2) || (base > 36))
1700 && (string[1] == 'x' || string[1] == 'X')
1701 && ISXDIGIT (string[2]))
1706 cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1707 cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1715 if (ISDIGIT (digit))
1716 digit = digit - '0';
1717 else if (ISALPHA (digit))
1718 digit = TOUPPER (digit) - 'A' + 10;
1721 if (digit >= (unsigned int) base)
1723 if (value > cutoff || (value == cutoff && digit > cutlim))
1725 value = value * base + digit;
1730 value = ~ (bfd_vma) 0;
1740 bfd_copy_private_header_data
1743 bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1746 Copy private BFD header information from the BFD @var{ibfd} to the
1747 the BFD @var{obfd}. This copies information that may require
1748 sections to exist, but does not require symbol tables. Return
1749 <<true>> on success, <<false>> on error.
1750 Possible error returns are:
1752 o <<bfd_error_no_memory>> -
1753 Not enough memory exists to create private data for @var{obfd}.
1755 .#define bfd_copy_private_header_data(ibfd, obfd) \
1756 . BFD_SEND (obfd, _bfd_copy_private_header_data, \
1763 bfd_copy_private_bfd_data
1766 bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1769 Copy private BFD information from the BFD @var{ibfd} to the
1770 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error.
1771 Possible error returns are:
1773 o <<bfd_error_no_memory>> -
1774 Not enough memory exists to create private data for @var{obfd}.
1776 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1777 . BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1784 bfd_set_private_flags
1787 bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1790 Set private BFD flag information in the BFD @var{abfd}.
1791 Return <<TRUE>> on success, <<FALSE>> on error. Possible error
1794 o <<bfd_error_no_memory>> -
1795 Not enough memory exists to create private data for @var{obfd}.
1797 .#define bfd_set_private_flags(abfd, flags) \
1798 . BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1807 The following functions exist but have not yet been documented.
1809 .#define bfd_sizeof_headers(abfd, info) \
1810 . BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
1812 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1813 . BFD_SEND (abfd, _bfd_find_nearest_line, \
1814 . (abfd, syms, sec, off, file, func, line, NULL))
1816 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \
1818 . BFD_SEND (abfd, _bfd_find_nearest_line, \
1819 . (abfd, syms, sec, off, file, func, line, disc))
1821 .#define bfd_find_line(abfd, syms, sym, file, line) \
1822 . BFD_SEND (abfd, _bfd_find_line, \
1823 . (abfd, syms, sym, file, line))
1825 .#define bfd_find_inliner_info(abfd, file, func, line) \
1826 . BFD_SEND (abfd, _bfd_find_inliner_info, \
1827 . (abfd, file, func, line))
1829 .#define bfd_debug_info_start(abfd) \
1830 . BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1832 .#define bfd_debug_info_end(abfd) \
1833 . BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1835 .#define bfd_debug_info_accumulate(abfd, section) \
1836 . BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1838 .#define bfd_stat_arch_elt(abfd, stat) \
1839 . BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1841 .#define bfd_update_armap_timestamp(abfd) \
1842 . BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1844 .#define bfd_set_arch_mach(abfd, arch, mach)\
1845 . BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1847 .#define bfd_relax_section(abfd, section, link_info, again) \
1848 . BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1850 .#define bfd_gc_sections(abfd, link_info) \
1851 . BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1853 .#define bfd_lookup_section_flags(link_info, flag_info, section) \
1854 . BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section))
1856 .#define bfd_merge_sections(abfd, link_info) \
1857 . BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1859 .#define bfd_is_group_section(abfd, sec) \
1860 . BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1862 .#define bfd_discard_group(abfd, sec) \
1863 . BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1865 .#define bfd_link_hash_table_create(abfd) \
1866 . BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1868 .#define bfd_link_add_symbols(abfd, info) \
1869 . BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1871 .#define bfd_link_just_syms(abfd, sec, info) \
1872 . BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1874 .#define bfd_final_link(abfd, info) \
1875 . BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1877 .#define bfd_free_cached_info(abfd) \
1878 . BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1880 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1881 . BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1883 .#define bfd_print_private_bfd_data(abfd, file)\
1884 . BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1886 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1887 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1889 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1890 . BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1891 . dyncount, dynsyms, ret))
1893 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1894 . BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1896 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1897 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1899 .extern bfd_byte *bfd_get_relocated_section_contents
1900 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1901 . bfd_boolean, asymbol **);
1907 bfd_get_relocated_section_contents (bfd *abfd,
1908 struct bfd_link_info *link_info,
1909 struct bfd_link_order *link_order,
1911 bfd_boolean relocatable,
1915 bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1916 bfd_byte *, bfd_boolean, asymbol **);
1918 if (link_order->type == bfd_indirect_link_order)
1920 abfd2 = link_order->u.indirect.section->owner;
1927 fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1929 return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1932 /* Record information about an ELF program header. */
1935 bfd_record_phdr (bfd *abfd,
1937 bfd_boolean flags_valid,
1939 bfd_boolean at_valid,
1941 bfd_boolean includes_filehdr,
1942 bfd_boolean includes_phdrs,
1946 struct elf_segment_map *m, **pm;
1949 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1952 amt = sizeof (struct elf_segment_map);
1953 amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1954 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
1961 m->p_flags_valid = flags_valid;
1962 m->p_paddr_valid = at_valid;
1963 m->includes_filehdr = includes_filehdr;
1964 m->includes_phdrs = includes_phdrs;
1967 memcpy (m->sections, secs, count * sizeof (asection *));
1969 for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
1977 /* Return true iff this target is 32-bit. */
1982 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1984 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1985 return bed->s->elfclass == ELFCLASS32;
1988 /* For non-ELF targets, use architecture information. */
1989 return bfd_arch_bits_per_address (abfd) <= 32;
1993 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
1994 target's address size. */
1997 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
2002 sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
2006 sprintf_vma (buf, value);
2010 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
2015 fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
2019 fprintf_vma ((FILE *) stream, value);
2027 bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
2031 When more than one machine code number is available for the
2032 same machine type, this function can be used to switch between
2033 the preferred one (alternative == 0) and any others. Currently,
2034 only ELF supports this feature, with up to two alternate
2039 bfd_alt_mach_code (bfd *abfd, int alternative)
2041 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2045 switch (alternative)
2048 code = get_elf_backend_data (abfd)->elf_machine_code;
2052 code = get_elf_backend_data (abfd)->elf_machine_alt1;
2058 code = get_elf_backend_data (abfd)->elf_machine_alt2;
2067 elf_elfheader (abfd)->e_machine = code;
2077 bfd_emul_get_maxpagesize
2080 bfd_vma bfd_emul_get_maxpagesize (const char *);
2083 Returns the maximum page size, in bytes, as determined by
2087 Returns the maximum page size in bytes for ELF, 0 otherwise.
2091 bfd_emul_get_maxpagesize (const char *emul)
2093 const bfd_target *target;
2095 target = bfd_find_target (emul, NULL);
2097 && target->flavour == bfd_target_elf_flavour)
2098 return xvec_get_elf_backend_data (target)->maxpagesize;
2104 bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size,
2105 int offset, const bfd_target *orig_target)
2107 if (target->flavour == bfd_target_elf_flavour)
2109 const struct elf_backend_data *bed;
2111 bed = xvec_get_elf_backend_data (target);
2112 *((bfd_vma *) ((char *) bed + offset)) = size;
2115 if (target->alternative_target
2116 && target->alternative_target != orig_target)
2117 bfd_elf_set_pagesize (target->alternative_target, size, offset,
2123 bfd_emul_set_maxpagesize
2126 void bfd_emul_set_maxpagesize (const char *, bfd_vma);
2129 For ELF, set the maximum page size for the emulation. It is
2130 a no-op for other formats.
2135 bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
2137 const bfd_target *target;
2139 target = bfd_find_target (emul, NULL);
2141 bfd_elf_set_pagesize (target, size,
2142 offsetof (struct elf_backend_data,
2143 maxpagesize), target);
2148 bfd_emul_get_commonpagesize
2151 bfd_vma bfd_emul_get_commonpagesize (const char *, bfd_boolean);
2154 Returns the common page size, in bytes, as determined by
2158 Returns the common page size in bytes for ELF, 0 otherwise.
2162 bfd_emul_get_commonpagesize (const char *emul, bfd_boolean relro)
2164 const bfd_target *target;
2166 target = bfd_find_target (emul, NULL);
2168 && target->flavour == bfd_target_elf_flavour)
2170 const struct elf_backend_data *bed;
2172 bed = xvec_get_elf_backend_data (target);
2174 return bed->relropagesize;
2176 return bed->commonpagesize;
2183 bfd_emul_set_commonpagesize
2186 void bfd_emul_set_commonpagesize (const char *, bfd_vma);
2189 For ELF, set the common page size for the emulation. It is
2190 a no-op for other formats.
2195 bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)
2197 const bfd_target *target;
2199 target = bfd_find_target (emul, NULL);
2201 bfd_elf_set_pagesize (target, size,
2202 offsetof (struct elf_backend_data,
2203 commonpagesize), target);
2211 char *bfd_demangle (bfd *, const char *, int);
2214 Wrapper around cplus_demangle. Strips leading underscores and
2215 other such chars that would otherwise confuse the demangler.
2216 If passed a g++ v3 ABI mangled name, returns a buffer allocated
2217 with malloc holding the demangled name. Returns NULL otherwise
2218 and on memory alloc failure.
2222 bfd_demangle (bfd *abfd, const char *name, int options)
2225 const char *pre, *suf;
2227 bfd_boolean skip_lead;
2229 skip_lead = (abfd != NULL
2231 && bfd_get_symbol_leading_char (abfd) == *name);
2235 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
2236 or the MS PE format. These formats have a number of leading '.'s
2237 on at least some symbols, so we remove all dots to avoid
2238 confusing the demangler. */
2240 while (*name == '.' || *name == '$')
2242 pre_len = name - pre;
2244 /* Strip off @plt and suchlike too. */
2246 suf = strchr (name, '@');
2249 alloc = (char *) bfd_malloc (suf - name + 1);
2252 memcpy (alloc, name, suf - name);
2253 alloc[suf - name] = '\0';
2257 res = cplus_demangle (name, options);
2266 size_t len = strlen (pre) + 1;
2267 alloc = (char *) bfd_malloc (len);
2270 memcpy (alloc, pre, len);
2276 /* Put back any prefix or suffix. */
2277 if (pre_len != 0 || suf != NULL)
2286 suf_len = strlen (suf) + 1;
2287 final = (char *) bfd_malloc (pre_len + len + suf_len);
2290 memcpy (final, pre, pre_len);
2291 memcpy (final + pre_len, res, len);
2292 memcpy (final + pre_len + len, suf, suf_len);
2303 bfd_update_compression_header
2306 void bfd_update_compression_header
2307 (bfd *abfd, bfd_byte *contents, asection *sec);
2310 Set the compression header at CONTENTS of SEC in ABFD and update
2311 elf_section_flags for compression.
2315 bfd_update_compression_header (bfd *abfd, bfd_byte *contents,
2318 if ((abfd->flags & BFD_COMPRESS) != 0)
2320 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2322 if ((abfd->flags & BFD_COMPRESS_GABI) != 0)
2324 const struct elf_backend_data *bed
2325 = get_elf_backend_data (abfd);
2327 /* Set the SHF_COMPRESSED bit. */
2328 elf_section_flags (sec) |= SHF_COMPRESSED;
2330 if (bed->s->elfclass == ELFCLASS32)
2332 Elf32_External_Chdr *echdr
2333 = (Elf32_External_Chdr *) contents;
2334 bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2335 bfd_put_32 (abfd, sec->size, &echdr->ch_size);
2336 bfd_put_32 (abfd, 1 << sec->alignment_power,
2337 &echdr->ch_addralign);
2338 /* bfd_log2 (alignof (Elf32_Chdr)) */
2339 bfd_set_section_alignment (abfd, sec, 2);
2343 Elf64_External_Chdr *echdr
2344 = (Elf64_External_Chdr *) contents;
2345 bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2346 bfd_put_32 (abfd, 0, &echdr->ch_reserved);
2347 bfd_put_64 (abfd, sec->size, &echdr->ch_size);
2348 bfd_put_64 (abfd, 1 << sec->alignment_power,
2349 &echdr->ch_addralign);
2350 /* bfd_log2 (alignof (Elf64_Chdr)) */
2351 bfd_set_section_alignment (abfd, sec, 3);
2356 /* Clear the SHF_COMPRESSED bit. */
2357 elf_section_flags (sec) &= ~SHF_COMPRESSED;
2359 /* Write the zlib header. It should be "ZLIB" followed by
2360 the uncompressed section size, 8 bytes in big-endian
2362 memcpy (contents, "ZLIB", 4);
2363 bfd_putb64 (sec->size, contents + 4);
2364 /* No way to keep the original alignment, just use 1 always. */
2365 bfd_set_section_alignment (abfd, sec, 0);
2375 bfd_check_compression_header
2378 bfd_boolean bfd_check_compression_header
2379 (bfd *abfd, bfd_byte *contents, asection *sec,
2380 bfd_size_type *uncompressed_size,
2381 unsigned int *uncompressed_alignment_power);
2384 Check the compression header at CONTENTS of SEC in ABFD and
2385 store the uncompressed size in UNCOMPRESSED_SIZE and the
2386 uncompressed data alignment in UNCOMPRESSED_ALIGNMENT_POWER
2387 if the compression header is valid.
2390 Return TRUE if the compression header is valid.
2394 bfd_check_compression_header (bfd *abfd, bfd_byte *contents,
2396 bfd_size_type *uncompressed_size,
2397 unsigned int *uncompressed_alignment_power)
2399 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2400 && (elf_section_flags (sec) & SHF_COMPRESSED) != 0)
2402 Elf_Internal_Chdr chdr;
2403 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2404 if (bed->s->elfclass == ELFCLASS32)
2406 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2407 chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type);
2408 chdr.ch_size = bfd_get_32 (abfd, &echdr->ch_size);
2409 chdr.ch_addralign = bfd_get_32 (abfd, &echdr->ch_addralign);
2413 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2414 chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type);
2415 chdr.ch_size = bfd_get_64 (abfd, &echdr->ch_size);
2416 chdr.ch_addralign = bfd_get_64 (abfd, &echdr->ch_addralign);
2418 if (chdr.ch_type == ELFCOMPRESS_ZLIB
2419 && chdr.ch_addralign == (1U << bfd_log2 (chdr.ch_addralign)))
2421 *uncompressed_size = chdr.ch_size;
2422 *uncompressed_alignment_power = bfd_log2 (chdr.ch_addralign);
2432 bfd_get_compression_header_size
2435 int bfd_get_compression_header_size (bfd *abfd, asection *sec);
2438 Return the size of the compression header of SEC in ABFD.
2441 Return the size of the compression header in bytes.
2445 bfd_get_compression_header_size (bfd *abfd, asection *sec)
2447 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2451 if (!(abfd->flags & BFD_COMPRESS_GABI))
2454 else if (!(elf_section_flags (sec) & SHF_COMPRESSED))
2457 if (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS32)
2458 return sizeof (Elf32_External_Chdr);
2460 return sizeof (Elf64_External_Chdr);
2468 bfd_convert_section_size
2471 bfd_size_type bfd_convert_section_size
2472 (bfd *ibfd, asection *isec, bfd *obfd, bfd_size_type size);
2475 Convert the size @var{size} of the section @var{isec} in input
2476 BFD @var{ibfd} to the section size in output BFD @var{obfd}.
2480 bfd_convert_section_size (bfd *ibfd, sec_ptr isec, bfd *obfd,
2483 bfd_size_type hdr_size;
2485 /* Do nothing if either input or output aren't ELF. */
2486 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2487 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2490 /* Do nothing if ELF classes of input and output are the same. */
2491 if (get_elf_backend_data (ibfd)->s->elfclass
2492 == get_elf_backend_data (obfd)->s->elfclass)
2495 /* Convert GNU property size. */
2496 if (CONST_STRNEQ (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME))
2497 return _bfd_elf_convert_gnu_property_size (ibfd, obfd);
2499 /* Do nothing if input file will be decompressed. */
2500 if ((ibfd->flags & BFD_DECOMPRESS))
2503 /* Do nothing if the input section isn't a SHF_COMPRESSED section. */
2504 hdr_size = bfd_get_compression_header_size (ibfd, isec);
2508 /* Adjust the size of the output SHF_COMPRESSED section. */
2509 if (hdr_size == sizeof (Elf32_External_Chdr))
2510 return (size - sizeof (Elf32_External_Chdr)
2511 + sizeof (Elf64_External_Chdr));
2513 return (size - sizeof (Elf64_External_Chdr)
2514 + sizeof (Elf32_External_Chdr));
2519 bfd_convert_section_contents
2522 bfd_boolean bfd_convert_section_contents
2523 (bfd *ibfd, asection *isec, bfd *obfd,
2524 bfd_byte **ptr, bfd_size_type *ptr_size);
2527 Convert the contents, stored in @var{*ptr}, of the section
2528 @var{isec} in input BFD @var{ibfd} to output BFD @var{obfd}
2529 if needed. The original buffer pointed to by @var{*ptr} may
2530 be freed and @var{*ptr} is returned with memory malloc'd by this
2531 function, and the new size written to @var{ptr_size}.
2535 bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
2536 bfd_byte **ptr, bfd_size_type *ptr_size)
2539 bfd_size_type ihdr_size, ohdr_size, size;
2540 Elf_Internal_Chdr chdr;
2541 bfd_boolean use_memmove;
2543 /* Do nothing if either input or output aren't ELF. */
2544 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2545 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2548 /* Do nothing if ELF classes of input and output are the same. */
2549 if (get_elf_backend_data (ibfd)->s->elfclass
2550 == get_elf_backend_data (obfd)->s->elfclass)
2553 /* Convert GNU properties. */
2554 if (CONST_STRNEQ (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME))
2555 return _bfd_elf_convert_gnu_properties (ibfd, isec, obfd, ptr,
2558 /* Do nothing if input file will be decompressed. */
2559 if ((ibfd->flags & BFD_DECOMPRESS))
2562 /* Do nothing if the input section isn't a SHF_COMPRESSED section. */
2563 ihdr_size = bfd_get_compression_header_size (ibfd, isec);
2569 /* Convert the contents of the input SHF_COMPRESSED section to
2570 output. Get the input compression header and the size of the
2571 output compression header. */
2572 if (ihdr_size == sizeof (Elf32_External_Chdr))
2574 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2575 chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type);
2576 chdr.ch_size = bfd_get_32 (ibfd, &echdr->ch_size);
2577 chdr.ch_addralign = bfd_get_32 (ibfd, &echdr->ch_addralign);
2579 ohdr_size = sizeof (Elf64_External_Chdr);
2581 use_memmove = FALSE;
2585 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2586 chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type);
2587 chdr.ch_size = bfd_get_64 (ibfd, &echdr->ch_size);
2588 chdr.ch_addralign = bfd_get_64 (ibfd, &echdr->ch_addralign);
2590 ohdr_size = sizeof (Elf32_External_Chdr);
2594 size = bfd_get_section_size (isec) - ihdr_size + ohdr_size;
2597 contents = (bfd_byte *) bfd_malloc (size);
2598 if (contents == NULL)
2602 /* Write out the output compression header. */
2603 if (ohdr_size == sizeof (Elf32_External_Chdr))
2605 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents;
2606 bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2607 bfd_put_32 (obfd, chdr.ch_size, &echdr->ch_size);
2608 bfd_put_32 (obfd, chdr.ch_addralign, &echdr->ch_addralign);
2612 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
2613 bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
2614 bfd_put_32 (obfd, 0, &echdr->ch_reserved);
2615 bfd_put_64 (obfd, chdr.ch_size, &echdr->ch_size);
2616 bfd_put_64 (obfd, chdr.ch_addralign, &echdr->ch_addralign);
2619 /* Copy the compressed contents. */
2621 memmove (contents + ohdr_size, *ptr + ihdr_size, size - ohdr_size);
2624 memcpy (contents + ohdr_size, *ptr + ihdr_size, size - ohdr_size);