daily update
[platform/upstream/binutils.git] / bfd / bfd.c
1 /* Generic BFD library interface and support routines.
2    Copyright 1990-2013 Free Software Foundation, Inc.
3    Written by Cygnus Support.
4
5    This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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.  */
21
22 /*
23 INODE
24 typedef bfd, Error reporting, BFD front end, BFD front end
25
26 SECTION
27         <<typedef bfd>>
28
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.
32
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.
36
37 CODE_FRAGMENT
38 .
39 .enum bfd_direction
40 .  {
41 .    no_direction = 0,
42 .    read_direction = 1,
43 .    write_direction = 2,
44 .    both_direction = 3
45 .  };
46 .
47 .struct bfd
48 .{
49 .  {* A unique identifier of the BFD  *}
50 .  unsigned int id;
51 .
52 .  {* The filename the application opened the BFD with.  *}
53 .  const char *filename;
54 .
55 .  {* A pointer to the target jump table.  *}
56 .  const struct bfd_target *xvec;
57 .
58 .  {* The IOSTREAM, and corresponding IO vector that provide access
59 .     to the file backing the BFD.  *}
60 .  void *iostream;
61 .  const struct bfd_iovec *iovec;
62 .
63 .  {* The caching routines use these to maintain a
64 .     least-recently-used list of BFDs.  *}
65 .  struct bfd *lru_prev, *lru_next;
66 .
67 .  {* When a file is closed by the caching routines, BFD retains
68 .     state information on the file here...  *}
69 .  ufile_ptr where;
70 .
71 .  {* File modified time, if mtime_set is TRUE.  *}
72 .  long mtime;
73 .
74 .  {* Reserved for an unimplemented file locking extension.  *}
75 .  int ifd;
76 .
77 .  {* The format which belongs to the BFD. (object, core, etc.)  *}
78 .  bfd_format format;
79 .
80 .  {* The direction with which the BFD was opened.  *}
81 .  enum bfd_direction direction;
82 .
83 .  {* Format_specific flags.  *}
84 .  flagword flags;
85 .
86 .  {* Values that may appear in the flags field of a BFD.  These also
87 .     appear in the object_flags field of the bfd_target structure, where
88 .     they indicate the set of flags used by that backend (not all flags
89 .     are meaningful for all object file formats) (FIXME: at the moment,
90 .     the object_flags values have mostly just been copied from backend
91 .     to another, and are not necessarily correct).  *}
92 .
93 .#define BFD_NO_FLAGS   0x00
94 .
95 .  {* BFD contains relocation entries.  *}
96 .#define HAS_RELOC      0x01
97 .
98 .  {* BFD is directly executable.  *}
99 .#define EXEC_P         0x02
100 .
101 .  {* BFD has line number information (basically used for F_LNNO in a
102 .     COFF header).  *}
103 .#define HAS_LINENO     0x04
104 .
105 .  {* BFD has debugging information.  *}
106 .#define HAS_DEBUG      0x08
107 .
108 .  {* BFD has symbols.  *}
109 .#define HAS_SYMS       0x10
110 .
111 .  {* BFD has local symbols (basically used for F_LSYMS in a COFF
112 .     header).  *}
113 .#define HAS_LOCALS     0x20
114 .
115 .  {* BFD is a dynamic object.  *}
116 .#define DYNAMIC        0x40
117 .
118 .  {* Text section is write protected (if D_PAGED is not set, this is
119 .     like an a.out NMAGIC file) (the linker sets this by default, but
120 .     clears it for -r or -N).  *}
121 .#define WP_TEXT        0x80
122 .
123 .  {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
124 .     linker sets this by default, but clears it for -r or -n or -N).  *}
125 .#define D_PAGED        0x100
126 .
127 .  {* BFD is relaxable (this means that bfd_relax_section may be able to
128 .     do something) (sometimes bfd_relax_section can do something even if
129 .     this is not set).  *}
130 .#define BFD_IS_RELAXABLE 0x200
131 .
132 .  {* This may be set before writing out a BFD to request using a
133 .     traditional format.  For example, this is used to request that when
134 .     writing out an a.out object the symbols not be hashed to eliminate
135 .     duplicates.  *}
136 .#define BFD_TRADITIONAL_FORMAT 0x400
137 .
138 .  {* This flag indicates that the BFD contents are actually cached
139 .     in memory.  If this is set, iostream points to a bfd_in_memory
140 .     struct.  *}
141 .#define BFD_IN_MEMORY 0x800
142 .
143 .  {* The sections in this BFD specify a memory page.  *}
144 .#define HAS_LOAD_PAGE 0x1000
145 .
146 .  {* This BFD has been created by the linker and doesn't correspond
147 .     to any input file.  *}
148 .#define BFD_LINKER_CREATED 0x2000
149 .
150 .  {* This may be set before writing out a BFD to request that it
151 .     be written using values for UIDs, GIDs, timestamps, etc. that
152 .     will be consistent from run to run.  *}
153 .#define BFD_DETERMINISTIC_OUTPUT 0x4000
154 .
155 .  {* Compress sections in this BFD.  *}
156 .#define BFD_COMPRESS 0x8000
157 .
158 .  {* Decompress sections in this BFD.  *}
159 .#define BFD_DECOMPRESS 0x10000
160 .
161 .  {* BFD is a dummy, for plugins.  *}
162 .#define BFD_PLUGIN 0x20000
163 .
164 .  {* Flags bits to be saved in bfd_preserve_save.  *}
165 .#define BFD_FLAGS_SAVED \
166 .  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_PLUGIN)
167 .
168 .  {* Flags bits which are for BFD use only.  *}
169 .#define BFD_FLAGS_FOR_BFD_USE_MASK \
170 .  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
171 .   | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT)
172 .
173 .  {* Currently my_archive is tested before adding origin to
174 .     anything. I believe that this can become always an add of
175 .     origin, with origin set to 0 for non archive files.  *}
176 .  ufile_ptr origin;
177 .
178 .  {* The origin in the archive of the proxy entry.  This will
179 .     normally be the same as origin, except for thin archives,
180 .     when it will contain the current offset of the proxy in the
181 .     thin archive rather than the offset of the bfd in its actual
182 .     container.  *}
183 .  ufile_ptr proxy_origin;
184 .
185 .  {* A hash table for section names.  *}
186 .  struct bfd_hash_table section_htab;
187 .
188 .  {* Pointer to linked list of sections.  *}
189 .  struct bfd_section *sections;
190 .
191 .  {* The last section on the section list.  *}
192 .  struct bfd_section *section_last;
193 .
194 .  {* The number of sections.  *}
195 .  unsigned int section_count;
196 .
197 .  {* Stuff only useful for object files:
198 .     The start address.  *}
199 .  bfd_vma start_address;
200 .
201 .  {* Used for input and output.  *}
202 .  unsigned int symcount;
203 .
204 .  {* Symbol table for output BFD (with symcount entries).
205 .     Also used by the linker to cache input BFD symbols.  *}
206 .  struct bfd_symbol  **outsymbols;
207 .
208 .  {* Used for slurped dynamic symbol tables.  *}
209 .  unsigned int dynsymcount;
210 .
211 .  {* Pointer to structure which contains architecture information.  *}
212 .  const struct bfd_arch_info *arch_info;
213 .
214 .  {* Stuff only useful for archives.  *}
215 .  void *arelt_data;
216 .  struct bfd *my_archive;      {* The containing archive BFD.  *}
217 .  struct bfd *archive_next;    {* The next BFD in the archive.  *}
218 .  struct bfd *archive_head;    {* The first BFD in the archive.  *}
219 .  struct bfd *nested_archives; {* List of nested archive in a flattened
220 .                                  thin archive.  *}
221 .
222 .  {* A chain of BFD structures involved in a link.  *}
223 .  struct bfd *link_next;
224 .
225 .  {* A field used by _bfd_generic_link_add_archive_symbols.  This will
226 .     be used only for archive elements.  *}
227 .  int archive_pass;
228 .
229 .  {* Used by the back end to hold private data.  *}
230 .  union
231 .    {
232 .      struct aout_data_struct *aout_data;
233 .      struct artdata *aout_ar_data;
234 .      struct _oasys_data *oasys_obj_data;
235 .      struct _oasys_ar_data *oasys_ar_data;
236 .      struct coff_tdata *coff_obj_data;
237 .      struct pe_tdata *pe_obj_data;
238 .      struct xcoff_tdata *xcoff_obj_data;
239 .      struct ecoff_tdata *ecoff_obj_data;
240 .      struct ieee_data_struct *ieee_data;
241 .      struct ieee_ar_data_struct *ieee_ar_data;
242 .      struct srec_data_struct *srec_data;
243 .      struct verilog_data_struct *verilog_data;
244 .      struct ihex_data_struct *ihex_data;
245 .      struct tekhex_data_struct *tekhex_data;
246 .      struct elf_obj_tdata *elf_obj_data;
247 .      struct nlm_obj_tdata *nlm_obj_data;
248 .      struct bout_data_struct *bout_data;
249 .      struct mmo_data_struct *mmo_data;
250 .      struct sun_core_struct *sun_core_data;
251 .      struct sco5_core_struct *sco5_core_data;
252 .      struct trad_core_struct *trad_core_data;
253 .      struct som_data_struct *som_data;
254 .      struct hpux_core_struct *hpux_core_data;
255 .      struct hppabsd_core_struct *hppabsd_core_data;
256 .      struct sgi_core_struct *sgi_core_data;
257 .      struct lynx_core_struct *lynx_core_data;
258 .      struct osf_core_struct *osf_core_data;
259 .      struct cisco_core_struct *cisco_core_data;
260 .      struct versados_data_struct *versados_data;
261 .      struct netbsd_core_struct *netbsd_core_data;
262 .      struct mach_o_data_struct *mach_o_data;
263 .      struct mach_o_fat_data_struct *mach_o_fat_data;
264 .      struct plugin_data_struct *plugin_data;
265 .      struct bfd_pef_data_struct *pef_data;
266 .      struct bfd_pef_xlib_data_struct *pef_xlib_data;
267 .      struct bfd_sym_data_struct *sym_data;
268 .      void *any;
269 .    }
270 .  tdata;
271 .
272 .  {* Used by the application to hold private data.  *}
273 .  void *usrdata;
274 .
275 .  {* Where all the allocated stuff under this BFD goes.  This is a
276 .     struct objalloc *, but we use void * to avoid requiring the inclusion
277 .     of objalloc.h.  *}
278 .  void *memory;
279 .
280 .  {* Is the file descriptor being cached?  That is, can it be closed as
281 .     needed, and re-opened when accessed later?  *}
282 .  unsigned int cacheable : 1;
283 .
284 .  {* Marks whether there was a default target specified when the
285 .     BFD was opened. This is used to select which matching algorithm
286 .     to use to choose the back end.  *}
287 .  unsigned int target_defaulted : 1;
288 .
289 .  {* ... and here: (``once'' means at least once).  *}
290 .  unsigned int opened_once : 1;
291 .
292 .  {* Set if we have a locally maintained mtime value, rather than
293 .     getting it from the file each time.  *}
294 .  unsigned int mtime_set : 1;
295 .
296 .  {* Flag set if symbols from this BFD should not be exported.  *}
297 .  unsigned int no_export : 1;
298 .
299 .  {* Remember when output has begun, to stop strange things
300 .     from happening.  *}
301 .  unsigned int output_has_begun : 1;
302 .
303 .  {* Have archive map.  *}
304 .  unsigned int has_armap : 1;
305 .
306 .  {* Set if this is a thin archive.  *}
307 .  unsigned int is_thin_archive : 1;
308 .
309 .  {* Set if only required symbols should be added in the link hash table for
310 .     this object.  Used by VMS linkers.  *}
311 .  unsigned int selective_search : 1;
312 .};
313 .
314 */
315
316 #include "sysdep.h"
317 #include <stdarg.h>
318 #include "bfd.h"
319 #include "bfdver.h"
320 #include "libiberty.h"
321 #include "demangle.h"
322 #include "safe-ctype.h"
323 #include "bfdlink.h"
324 #include "libbfd.h"
325 #include "coff/internal.h"
326 #include "coff/sym.h"
327 #include "libcoff.h"
328 #include "libecoff.h"
329 #undef obj_symbols
330 #include "elf-bfd.h"
331
332 #ifndef EXIT_FAILURE
333 #define EXIT_FAILURE 1
334 #endif
335
336 \f
337 /* provide storage for subsystem, stack and heap data which may have been
338    passed in on the command line.  Ld puts this data into a bfd_link_info
339    struct which ultimately gets passed in to the bfd.  When it arrives, copy
340    it to the following struct so that the data will be available in coffcode.h
341    where it is needed.  The typedef's used are defined in bfd.h */
342 \f
343 /*
344 INODE
345 Error reporting, Miscellaneous, typedef bfd, BFD front end
346
347 SECTION
348         Error reporting
349
350         Most BFD functions return nonzero on success (check their
351         individual documentation for precise semantics).  On an error,
352         they call <<bfd_set_error>> to set an error condition that callers
353         can check by calling <<bfd_get_error>>.
354         If that returns <<bfd_error_system_call>>, then check
355         <<errno>>.
356
357         The easiest way to report a BFD error to the user is to
358         use <<bfd_perror>>.
359
360 SUBSECTION
361         Type <<bfd_error_type>>
362
363         The values returned by <<bfd_get_error>> are defined by the
364         enumerated type <<bfd_error_type>>.
365
366 CODE_FRAGMENT
367 .
368 .typedef enum bfd_error
369 .{
370 .  bfd_error_no_error = 0,
371 .  bfd_error_system_call,
372 .  bfd_error_invalid_target,
373 .  bfd_error_wrong_format,
374 .  bfd_error_wrong_object_format,
375 .  bfd_error_invalid_operation,
376 .  bfd_error_no_memory,
377 .  bfd_error_no_symbols,
378 .  bfd_error_no_armap,
379 .  bfd_error_no_more_archived_files,
380 .  bfd_error_malformed_archive,
381 .  bfd_error_missing_dso,
382 .  bfd_error_file_not_recognized,
383 .  bfd_error_file_ambiguously_recognized,
384 .  bfd_error_no_contents,
385 .  bfd_error_nonrepresentable_section,
386 .  bfd_error_no_debug_section,
387 .  bfd_error_bad_value,
388 .  bfd_error_file_truncated,
389 .  bfd_error_file_too_big,
390 .  bfd_error_on_input,
391 .  bfd_error_invalid_error_code
392 .}
393 .bfd_error_type;
394 .
395 */
396
397 static bfd_error_type bfd_error = bfd_error_no_error;
398 static bfd *input_bfd = NULL;
399 static bfd_error_type input_error = bfd_error_no_error;
400
401 const char *const bfd_errmsgs[] =
402 {
403   N_("No error"),
404   N_("System call error"),
405   N_("Invalid bfd target"),
406   N_("File in wrong format"),
407   N_("Archive object file in wrong format"),
408   N_("Invalid operation"),
409   N_("Memory exhausted"),
410   N_("No symbols"),
411   N_("Archive has no index; run ranlib to add one"),
412   N_("No more archived files"),
413   N_("Malformed archive"),
414   N_("DSO missing from command line"),
415   N_("File format not recognized"),
416   N_("File format is ambiguous"),
417   N_("Section has no contents"),
418   N_("Nonrepresentable section on output"),
419   N_("Symbol needs debug section which does not exist"),
420   N_("Bad value"),
421   N_("File truncated"),
422   N_("File too big"),
423   N_("Error reading %s: %s"),
424   N_("#<Invalid error code>")
425 };
426
427 /*
428 FUNCTION
429         bfd_get_error
430
431 SYNOPSIS
432         bfd_error_type bfd_get_error (void);
433
434 DESCRIPTION
435         Return the current BFD error condition.
436 */
437
438 bfd_error_type
439 bfd_get_error (void)
440 {
441   return bfd_error;
442 }
443
444 /*
445 FUNCTION
446         bfd_set_error
447
448 SYNOPSIS
449         void bfd_set_error (bfd_error_type error_tag, ...);
450
451 DESCRIPTION
452         Set the BFD error condition to be @var{error_tag}.
453         If @var{error_tag} is bfd_error_on_input, then this function
454         takes two more parameters, the input bfd where the error
455         occurred, and the bfd_error_type error.
456 */
457
458 void
459 bfd_set_error (bfd_error_type error_tag, ...)
460 {
461   bfd_error = error_tag;
462   if (error_tag == bfd_error_on_input)
463     {
464       /* This is an error that occurred during bfd_close when
465          writing an archive, but on one of the input files.  */
466       va_list ap;
467
468       va_start (ap, error_tag);
469       input_bfd = va_arg (ap, bfd *);
470       input_error = (bfd_error_type) va_arg (ap, int);
471       if (input_error >= bfd_error_on_input)
472         abort ();
473       va_end (ap);
474     }
475 }
476
477 /*
478 FUNCTION
479         bfd_errmsg
480
481 SYNOPSIS
482         const char *bfd_errmsg (bfd_error_type error_tag);
483
484 DESCRIPTION
485         Return a string describing the error @var{error_tag}, or
486         the system error if @var{error_tag} is <<bfd_error_system_call>>.
487 */
488
489 const char *
490 bfd_errmsg (bfd_error_type error_tag)
491 {
492 #ifndef errno
493   extern int errno;
494 #endif
495   if (error_tag == bfd_error_on_input)
496     {
497       char *buf;
498       const char *msg = bfd_errmsg (input_error);
499
500       if (asprintf (&buf, _(bfd_errmsgs [error_tag]), input_bfd->filename, msg)
501           != -1)
502         return buf;
503
504       /* Ick, what to do on out of memory?  */
505       return msg;
506     }
507
508   if (error_tag == bfd_error_system_call)
509     return xstrerror (errno);
510
511   if (error_tag > bfd_error_invalid_error_code)
512     error_tag = bfd_error_invalid_error_code;   /* sanity check */
513
514   return _(bfd_errmsgs [error_tag]);
515 }
516
517 /*
518 FUNCTION
519         bfd_perror
520
521 SYNOPSIS
522         void bfd_perror (const char *message);
523
524 DESCRIPTION
525         Print to the standard error stream a string describing the
526         last BFD error that occurred, or the last system error if
527         the last BFD error was a system call failure.  If @var{message}
528         is non-NULL and non-empty, the error string printed is preceded
529         by @var{message}, a colon, and a space.  It is followed by a newline.
530 */
531
532 void
533 bfd_perror (const char *message)
534 {
535   fflush (stdout);
536   if (message == NULL || *message == '\0')
537     fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
538   else
539     fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
540   fflush (stderr);
541 }
542
543 /*
544 SUBSECTION
545         BFD error handler
546
547         Some BFD functions want to print messages describing the
548         problem.  They call a BFD error handler function.  This
549         function may be overridden by the program.
550
551         The BFD error handler acts like printf.
552
553 CODE_FRAGMENT
554 .
555 .typedef void (*bfd_error_handler_type) (const char *, ...);
556 .
557 */
558
559 /* The program name used when printing BFD error messages.  */
560
561 static const char *_bfd_error_program_name;
562
563 /* This is the default routine to handle BFD error messages.
564    Like fprintf (stderr, ...), but also handles some extra format specifiers.
565
566    %A section name from section.  For group components, print group name too.
567    %B file name from bfd.  For archive components, prints archive too.
568
569    Note - because these two extra format specifiers require special handling
570    they are scanned for and processed in this function, before calling
571    vfprintf.  This means that the *arguments* for these format specifiers
572    must be the first ones in the variable argument list, regardless of where
573    the specifiers appear in the format string.  Thus for example calling
574    this function with a format string of:
575
576       "blah %s blah %A blah %d blah %B"
577
578    would involve passing the arguments as:
579
580       "blah %s blah %A blah %d blah %B",
581         asection_for_the_%A,
582         bfd_for_the_%B,
583         string_for_the_%s,
584         integer_for_the_%d);
585  */
586
587 void
588 _bfd_default_error_handler (const char *fmt, ...)
589 {
590   va_list ap;
591   char *bufp;
592   const char *new_fmt, *p;
593   size_t avail = 1000;
594   char buf[1000];
595
596   /* PR 4992: Don't interrupt output being sent to stdout.  */
597   fflush (stdout);
598
599   if (_bfd_error_program_name != NULL)
600     fprintf (stderr, "%s: ", _bfd_error_program_name);
601   else
602     fprintf (stderr, "BFD: ");
603
604   va_start (ap, fmt);
605   new_fmt = fmt;
606   bufp = buf;
607
608   /* Reserve enough space for the existing format string.  */
609   avail -= strlen (fmt) + 1;
610   if (avail > 1000)
611     _exit (EXIT_FAILURE);
612
613   p = fmt;
614   while (1)
615     {
616       char *q;
617       size_t len, extra, trim;
618
619       p = strchr (p, '%');
620       if (p == NULL || p[1] == '\0')
621         {
622           if (new_fmt == buf)
623             {
624               len = strlen (fmt);
625               memcpy (bufp, fmt, len + 1);
626             }
627           break;
628         }
629
630       if (p[1] == 'A' || p[1] == 'B')
631         {
632           len = p - fmt;
633           memcpy (bufp, fmt, len);
634           bufp += len;
635           fmt = p + 2;
636           new_fmt = buf;
637
638           /* If we run out of space, tough, you lose your ridiculously
639              long file or section name.  It's not safe to try to alloc
640              memory here;  We might be printing an out of memory message.  */
641           if (avail == 0)
642             {
643               *bufp++ = '*';
644               *bufp++ = '*';
645               *bufp = '\0';
646             }
647           else
648             {
649               if (p[1] == 'B')
650                 {
651                   bfd *abfd = va_arg (ap, bfd *);
652
653                   if (abfd == NULL)
654                     /* Invoking %B with a null bfd pointer is an internal error.  */
655                     abort ();
656                   else if (abfd->my_archive)
657                     snprintf (bufp, avail, "%s(%s)",
658                               abfd->my_archive->filename, abfd->filename);
659                   else
660                     snprintf (bufp, avail, "%s", abfd->filename);
661                 }
662               else
663                 {
664                   asection *sec = va_arg (ap, asection *);
665                   bfd *abfd;
666                   const char *group = NULL;
667                   struct coff_comdat_info *ci;
668
669                   if (sec == NULL)
670                     /* Invoking %A with a null section pointer is an internal error.  */
671                     abort ();
672                   abfd = sec->owner;
673                   if (abfd != NULL
674                       && bfd_get_flavour (abfd) == bfd_target_elf_flavour
675                       && elf_next_in_group (sec) != NULL
676                       && (sec->flags & SEC_GROUP) == 0)
677                     group = elf_group_name (sec);
678                   else if (abfd != NULL
679                            && bfd_get_flavour (abfd) == bfd_target_coff_flavour
680                            && (ci = bfd_coff_get_comdat_section (sec->owner,
681                                                                  sec)) != NULL)
682                     group = ci->name;
683                   if (group != NULL)
684                     snprintf (bufp, avail, "%s[%s]", sec->name, group);
685                   else
686                     snprintf (bufp, avail, "%s", sec->name);
687                 }
688               len = strlen (bufp);
689               avail = avail - len + 2;
690
691               /* We need to replace any '%' we printed by "%%".
692                  First count how many.  */
693               q = bufp;
694               bufp += len;
695               extra = 0;
696               while ((q = strchr (q, '%')) != NULL)
697                 {
698                   ++q;
699                   ++extra;
700                 }
701
702               /* If there isn't room, trim off the end of the string.  */
703               q = bufp;
704               bufp += extra;
705               if (extra > avail)
706                 {
707                   trim = extra - avail;
708                   bufp -= trim;
709                   do
710                     {
711                       if (*--q == '%')
712                         --extra;
713                     }
714                   while (--trim != 0);
715                   *q = '\0';
716                   avail = extra;
717                 }
718               avail -= extra;
719
720               /* Now double all '%' chars, shuffling the string as we go.  */
721               while (extra != 0)
722                 {
723                   while ((q[extra] = *q) != '%')
724                     --q;
725                   q[--extra] = '%';
726                   --q;
727                 }
728             }
729         }
730       p = p + 2;
731     }
732
733   vfprintf (stderr, new_fmt, ap);
734   va_end (ap);
735
736   /* On AIX, putc is implemented as a macro that triggers a -Wunused-value
737      warning, so use the fputc function to avoid it.  */
738   fputc ('\n', stderr);
739   fflush (stderr);
740 }
741
742 /* This is a function pointer to the routine which should handle BFD
743    error messages.  It is called when a BFD routine encounters an
744    error for which it wants to print a message.  Going through a
745    function pointer permits a program linked against BFD to intercept
746    the messages and deal with them itself.  */
747
748 bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler;
749
750 /*
751 FUNCTION
752         bfd_set_error_handler
753
754 SYNOPSIS
755         bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
756
757 DESCRIPTION
758         Set the BFD error handler function.  Returns the previous
759         function.
760 */
761
762 bfd_error_handler_type
763 bfd_set_error_handler (bfd_error_handler_type pnew)
764 {
765   bfd_error_handler_type pold;
766
767   pold = _bfd_error_handler;
768   _bfd_error_handler = pnew;
769   return pold;
770 }
771
772 /*
773 FUNCTION
774         bfd_set_error_program_name
775
776 SYNOPSIS
777         void bfd_set_error_program_name (const char *);
778
779 DESCRIPTION
780         Set the program name to use when printing a BFD error.  This
781         is printed before the error message followed by a colon and
782         space.  The string must not be changed after it is passed to
783         this function.
784 */
785
786 void
787 bfd_set_error_program_name (const char *name)
788 {
789   _bfd_error_program_name = name;
790 }
791
792 /*
793 FUNCTION
794         bfd_get_error_handler
795
796 SYNOPSIS
797         bfd_error_handler_type bfd_get_error_handler (void);
798
799 DESCRIPTION
800         Return the BFD error handler function.
801 */
802
803 bfd_error_handler_type
804 bfd_get_error_handler (void)
805 {
806   return _bfd_error_handler;
807 }
808
809 /*
810 SUBSECTION
811         BFD assert handler
812
813         If BFD finds an internal inconsistency, the bfd assert
814         handler is called with information on the BFD version, BFD
815         source file and line.  If this happens, most programs linked
816         against BFD are expected to want to exit with an error, or mark
817         the current BFD operation as failed, so it is recommended to
818         override the default handler, which just calls
819         _bfd_error_handler and continues.
820
821 CODE_FRAGMENT
822 .
823 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg,
824 .                                         const char *bfd_version,
825 .                                         const char *bfd_file,
826 .                                         int bfd_line);
827 .
828 */
829
830 /* Note the use of bfd_ prefix on the parameter names above: we want to
831    show which one is the message and which is the version by naming the
832    parameters, but avoid polluting the program-using-bfd namespace as
833    the typedef is visible in the exported headers that the program
834    includes.  Below, it's just for consistency.  */
835
836 static void
837 _bfd_default_assert_handler (const char *bfd_formatmsg,
838                              const char *bfd_version,
839                              const char *bfd_file,
840                              int bfd_line)
841
842 {
843   (*_bfd_error_handler) (bfd_formatmsg, bfd_version, bfd_file, bfd_line);
844 }
845
846 /* Similar to _bfd_error_handler, a program can decide to exit on an
847    internal BFD error.  We use a non-variadic type to simplify passing
848    on parameters to other functions, e.g. _bfd_error_handler.  */
849
850 bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler;
851
852 /*
853 FUNCTION
854         bfd_set_assert_handler
855
856 SYNOPSIS
857         bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type);
858
859 DESCRIPTION
860         Set the BFD assert handler function.  Returns the previous
861         function.
862 */
863
864 bfd_assert_handler_type
865 bfd_set_assert_handler (bfd_assert_handler_type pnew)
866 {
867   bfd_assert_handler_type pold;
868
869   pold = _bfd_assert_handler;
870   _bfd_assert_handler = pnew;
871   return pold;
872 }
873
874 /*
875 FUNCTION
876         bfd_get_assert_handler
877
878 SYNOPSIS
879         bfd_assert_handler_type bfd_get_assert_handler (void);
880
881 DESCRIPTION
882         Return the BFD assert handler function.
883 */
884
885 bfd_assert_handler_type
886 bfd_get_assert_handler (void)
887 {
888   return _bfd_assert_handler;
889 }
890 \f
891 /*
892 INODE
893 Miscellaneous, Memory Usage, Error reporting, BFD front end
894
895 SECTION
896         Miscellaneous
897
898 SUBSECTION
899         Miscellaneous functions
900 */
901
902 /*
903 FUNCTION
904         bfd_get_reloc_upper_bound
905
906 SYNOPSIS
907         long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
908
909 DESCRIPTION
910         Return the number of bytes required to store the
911         relocation information associated with section @var{sect}
912         attached to bfd @var{abfd}.  If an error occurs, return -1.
913
914 */
915
916 long
917 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
918 {
919   if (abfd->format != bfd_object)
920     {
921       bfd_set_error (bfd_error_invalid_operation);
922       return -1;
923     }
924
925   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
926 }
927
928 /*
929 FUNCTION
930         bfd_canonicalize_reloc
931
932 SYNOPSIS
933         long bfd_canonicalize_reloc
934           (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
935
936 DESCRIPTION
937         Call the back end associated with the open BFD
938         @var{abfd} and translate the external form of the relocation
939         information attached to @var{sec} into the internal canonical
940         form.  Place the table into memory at @var{loc}, which has
941         been preallocated, usually by a call to
942         <<bfd_get_reloc_upper_bound>>.  Returns the number of relocs, or
943         -1 on error.
944
945         The @var{syms} table is also needed for horrible internal magic
946         reasons.
947
948 */
949 long
950 bfd_canonicalize_reloc (bfd *abfd,
951                         sec_ptr asect,
952                         arelent **location,
953                         asymbol **symbols)
954 {
955   if (abfd->format != bfd_object)
956     {
957       bfd_set_error (bfd_error_invalid_operation);
958       return -1;
959     }
960
961   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
962                    (abfd, asect, location, symbols));
963 }
964
965 /*
966 FUNCTION
967         bfd_set_reloc
968
969 SYNOPSIS
970         void bfd_set_reloc
971           (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
972
973 DESCRIPTION
974         Set the relocation pointer and count within
975         section @var{sec} to the values @var{rel} and @var{count}.
976         The argument @var{abfd} is ignored.
977
978 */
979
980 void
981 bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED,
982                sec_ptr asect,
983                arelent **location,
984                unsigned int count)
985 {
986   asect->orelocation = location;
987   asect->reloc_count = count;
988 }
989
990 /*
991 FUNCTION
992         bfd_set_file_flags
993
994 SYNOPSIS
995         bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
996
997 DESCRIPTION
998         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
999
1000         Possible errors are:
1001         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
1002         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
1003         o <<bfd_error_invalid_operation>> -
1004         The flag word contained a bit which was not applicable to the
1005         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
1006         on a BFD format which does not support demand paging.
1007
1008 */
1009
1010 bfd_boolean
1011 bfd_set_file_flags (bfd *abfd, flagword flags)
1012 {
1013   if (abfd->format != bfd_object)
1014     {
1015       bfd_set_error (bfd_error_wrong_format);
1016       return FALSE;
1017     }
1018
1019   if (bfd_read_p (abfd))
1020     {
1021       bfd_set_error (bfd_error_invalid_operation);
1022       return FALSE;
1023     }
1024
1025   bfd_get_file_flags (abfd) = flags;
1026   if ((flags & bfd_applicable_file_flags (abfd)) != flags)
1027     {
1028       bfd_set_error (bfd_error_invalid_operation);
1029       return FALSE;
1030     }
1031
1032   return TRUE;
1033 }
1034
1035 void
1036 bfd_assert (const char *file, int line)
1037 {
1038   (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"),
1039                           BFD_VERSION_STRING, file, line);
1040 }
1041
1042 /* A more or less friendly abort message.  In libbfd.h abort is
1043    defined to call this function.  */
1044
1045 void
1046 _bfd_abort (const char *file, int line, const char *fn)
1047 {
1048   if (fn != NULL)
1049     (*_bfd_error_handler)
1050       (_("BFD %s internal error, aborting at %s line %d in %s\n"),
1051        BFD_VERSION_STRING, file, line, fn);
1052   else
1053     (*_bfd_error_handler)
1054       (_("BFD %s internal error, aborting at %s line %d\n"),
1055        BFD_VERSION_STRING, file, line);
1056   (*_bfd_error_handler) (_("Please report this bug.\n"));
1057   _exit (EXIT_FAILURE);
1058 }
1059
1060 /*
1061 FUNCTION
1062         bfd_get_arch_size
1063
1064 SYNOPSIS
1065         int bfd_get_arch_size (bfd *abfd);
1066
1067 DESCRIPTION
1068         Returns the architecture address size, in bits, as determined
1069         by the object file's format.  For ELF, this information is
1070         included in the header.
1071
1072 RETURNS
1073         Returns the arch size in bits if known, <<-1>> otherwise.
1074 */
1075
1076 int
1077 bfd_get_arch_size (bfd *abfd)
1078 {
1079   if (abfd->xvec->flavour == bfd_target_elf_flavour)
1080     return get_elf_backend_data (abfd)->s->arch_size;
1081
1082   return -1;
1083 }
1084
1085 /*
1086 FUNCTION
1087         bfd_get_sign_extend_vma
1088
1089 SYNOPSIS
1090         int bfd_get_sign_extend_vma (bfd *abfd);
1091
1092 DESCRIPTION
1093         Indicates if the target architecture "naturally" sign extends
1094         an address.  Some architectures implicitly sign extend address
1095         values when they are converted to types larger than the size
1096         of an address.  For instance, bfd_get_start_address() will
1097         return an address sign extended to fill a bfd_vma when this is
1098         the case.
1099
1100 RETURNS
1101         Returns <<1>> if the target architecture is known to sign
1102         extend addresses, <<0>> if the target architecture is known to
1103         not sign extend addresses, and <<-1>> otherwise.
1104 */
1105
1106 int
1107 bfd_get_sign_extend_vma (bfd *abfd)
1108 {
1109   char *name;
1110
1111   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1112     return get_elf_backend_data (abfd)->sign_extend_vma;
1113
1114   name = bfd_get_target (abfd);
1115
1116   /* Return a proper value for DJGPP & PE COFF.
1117      This function is required for DWARF2 support, but there is
1118      no place to store this information in the COFF back end.
1119      Should enough other COFF targets add support for DWARF2,
1120      a place will have to be found.  Until then, this hack will do.  */
1121   if (CONST_STRNEQ (name, "coff-go32")
1122       || strcmp (name, "pe-i386") == 0
1123       || strcmp (name, "pei-i386") == 0
1124       || strcmp (name, "pe-x86-64") == 0
1125       || strcmp (name, "pei-x86-64") == 0
1126       || strcmp (name, "pe-arm-wince-little") == 0
1127       || strcmp (name, "pei-arm-wince-little") == 0
1128       || strcmp (name, "aixcoff-rs6000") == 0)
1129     return 1;
1130
1131   if (CONST_STRNEQ (name, "mach-o"))
1132     return 0;
1133
1134   bfd_set_error (bfd_error_wrong_format);
1135   return -1;
1136 }
1137
1138 /*
1139 FUNCTION
1140         bfd_set_start_address
1141
1142 SYNOPSIS
1143         bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
1144
1145 DESCRIPTION
1146         Make @var{vma} the entry point of output BFD @var{abfd}.
1147
1148 RETURNS
1149         Returns <<TRUE>> on success, <<FALSE>> otherwise.
1150 */
1151
1152 bfd_boolean
1153 bfd_set_start_address (bfd *abfd, bfd_vma vma)
1154 {
1155   abfd->start_address = vma;
1156   return TRUE;
1157 }
1158
1159 /*
1160 FUNCTION
1161         bfd_get_gp_size
1162
1163 SYNOPSIS
1164         unsigned int bfd_get_gp_size (bfd *abfd);
1165
1166 DESCRIPTION
1167         Return the maximum size of objects to be optimized using the GP
1168         register under MIPS ECOFF.  This is typically set by the <<-G>>
1169         argument to the compiler, assembler or linker.
1170 */
1171
1172 unsigned int
1173 bfd_get_gp_size (bfd *abfd)
1174 {
1175   if (abfd->format == bfd_object)
1176     {
1177       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1178         return ecoff_data (abfd)->gp_size;
1179       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1180         return elf_gp_size (abfd);
1181     }
1182   return 0;
1183 }
1184
1185 /*
1186 FUNCTION
1187         bfd_set_gp_size
1188
1189 SYNOPSIS
1190         void bfd_set_gp_size (bfd *abfd, unsigned int i);
1191
1192 DESCRIPTION
1193         Set the maximum size of objects to be optimized using the GP
1194         register under ECOFF or MIPS ELF.  This is typically set by
1195         the <<-G>> argument to the compiler, assembler or linker.
1196 */
1197
1198 void
1199 bfd_set_gp_size (bfd *abfd, unsigned int i)
1200 {
1201   /* Don't try to set GP size on an archive or core file!  */
1202   if (abfd->format != bfd_object)
1203     return;
1204
1205   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1206     ecoff_data (abfd)->gp_size = i;
1207   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1208     elf_gp_size (abfd) = i;
1209 }
1210
1211 /* Get the GP value.  This is an internal function used by some of the
1212    relocation special_function routines on targets which support a GP
1213    register.  */
1214
1215 bfd_vma
1216 _bfd_get_gp_value (bfd *abfd)
1217 {
1218   if (! abfd)
1219     return 0;
1220   if (abfd->format != bfd_object)
1221     return 0;
1222
1223   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1224     return ecoff_data (abfd)->gp;
1225   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1226     return elf_gp (abfd);
1227
1228   return 0;
1229 }
1230
1231 /* Set the GP value.  */
1232
1233 void
1234 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
1235 {
1236   if (! abfd)
1237     abort ();
1238   if (abfd->format != bfd_object)
1239     return;
1240
1241   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1242     ecoff_data (abfd)->gp = v;
1243   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1244     elf_gp (abfd) = v;
1245 }
1246
1247 /*
1248 FUNCTION
1249         bfd_scan_vma
1250
1251 SYNOPSIS
1252         bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
1253
1254 DESCRIPTION
1255         Convert, like <<strtoul>>, a numerical expression
1256         @var{string} into a <<bfd_vma>> integer, and return that integer.
1257         (Though without as many bells and whistles as <<strtoul>>.)
1258         The expression is assumed to be unsigned (i.e., positive).
1259         If given a @var{base}, it is used as the base for conversion.
1260         A base of 0 causes the function to interpret the string
1261         in hex if a leading "0x" or "0X" is found, otherwise
1262         in octal if a leading zero is found, otherwise in decimal.
1263
1264         If the value would overflow, the maximum <<bfd_vma>> value is
1265         returned.
1266 */
1267
1268 bfd_vma
1269 bfd_scan_vma (const char *string, const char **end, int base)
1270 {
1271   bfd_vma value;
1272   bfd_vma cutoff;
1273   unsigned int cutlim;
1274   int overflow;
1275
1276   /* Let the host do it if possible.  */
1277   if (sizeof (bfd_vma) <= sizeof (unsigned long))
1278     return strtoul (string, (char **) end, base);
1279
1280 #ifdef HAVE_STRTOULL
1281   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1282     return strtoull (string, (char **) end, base);
1283 #endif
1284
1285   if (base == 0)
1286     {
1287       if (string[0] == '0')
1288         {
1289           if ((string[1] == 'x') || (string[1] == 'X'))
1290             base = 16;
1291           else
1292             base = 8;
1293         }
1294     }
1295
1296   if ((base < 2) || (base > 36))
1297     base = 10;
1298
1299   if (base == 16
1300       && string[0] == '0'
1301       && (string[1] == 'x' || string[1] == 'X')
1302       && ISXDIGIT (string[2]))
1303     {
1304       string += 2;
1305     }
1306
1307   cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1308   cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1309   value = 0;
1310   overflow = 0;
1311   while (1)
1312     {
1313       unsigned int digit;
1314
1315       digit = *string;
1316       if (ISDIGIT (digit))
1317         digit = digit - '0';
1318       else if (ISALPHA (digit))
1319         digit = TOUPPER (digit) - 'A' + 10;
1320       else
1321         break;
1322       if (digit >= (unsigned int) base)
1323         break;
1324       if (value > cutoff || (value == cutoff && digit > cutlim))
1325         overflow = 1;
1326       value = value * base + digit;
1327       ++string;
1328     }
1329
1330   if (overflow)
1331     value = ~ (bfd_vma) 0;
1332
1333   if (end != NULL)
1334     *end = string;
1335
1336   return value;
1337 }
1338
1339 /*
1340 FUNCTION
1341         bfd_copy_private_header_data
1342
1343 SYNOPSIS
1344         bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1345
1346 DESCRIPTION
1347         Copy private BFD header information from the BFD @var{ibfd} to the
1348         the BFD @var{obfd}.  This copies information that may require
1349         sections to exist, but does not require symbol tables.  Return
1350         <<true>> on success, <<false>> on error.
1351         Possible error returns are:
1352
1353         o <<bfd_error_no_memory>> -
1354         Not enough memory exists to create private data for @var{obfd}.
1355
1356 .#define bfd_copy_private_header_data(ibfd, obfd) \
1357 .     BFD_SEND (obfd, _bfd_copy_private_header_data, \
1358 .               (ibfd, obfd))
1359
1360 */
1361
1362 /*
1363 FUNCTION
1364         bfd_copy_private_bfd_data
1365
1366 SYNOPSIS
1367         bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1368
1369 DESCRIPTION
1370         Copy private BFD information from the BFD @var{ibfd} to the
1371         the BFD @var{obfd}.  Return <<TRUE>> on success, <<FALSE>> on error.
1372         Possible error returns are:
1373
1374         o <<bfd_error_no_memory>> -
1375         Not enough memory exists to create private data for @var{obfd}.
1376
1377 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1378 .     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1379 .               (ibfd, obfd))
1380
1381 */
1382
1383 /*
1384 FUNCTION
1385         bfd_merge_private_bfd_data
1386
1387 SYNOPSIS
1388         bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
1389
1390 DESCRIPTION
1391         Merge private BFD information from the BFD @var{ibfd} to the
1392         the output file BFD @var{obfd} when linking.  Return <<TRUE>>
1393         on success, <<FALSE>> on error.  Possible error returns are:
1394
1395         o <<bfd_error_no_memory>> -
1396         Not enough memory exists to create private data for @var{obfd}.
1397
1398 .#define bfd_merge_private_bfd_data(ibfd, obfd) \
1399 .     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1400 .               (ibfd, obfd))
1401
1402 */
1403
1404 /*
1405 FUNCTION
1406         bfd_set_private_flags
1407
1408 SYNOPSIS
1409         bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1410
1411 DESCRIPTION
1412         Set private BFD flag information in the BFD @var{abfd}.
1413         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
1414         returns are:
1415
1416         o <<bfd_error_no_memory>> -
1417         Not enough memory exists to create private data for @var{obfd}.
1418
1419 .#define bfd_set_private_flags(abfd, flags) \
1420 .     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1421
1422 */
1423
1424 /*
1425 FUNCTION
1426         Other functions
1427
1428 DESCRIPTION
1429         The following functions exist but have not yet been documented.
1430
1431 .#define bfd_sizeof_headers(abfd, info) \
1432 .       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
1433 .
1434 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1435 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
1436 .                 (abfd, sec, syms, off, file, func, line))
1437 .
1438 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \
1439 .                                            line, disc) \
1440 .       BFD_SEND (abfd, _bfd_find_nearest_line_discriminator, \
1441 .                 (abfd, sec, syms, off, file, func, line, disc))
1442 .
1443 .#define bfd_find_line(abfd, syms, sym, file, line) \
1444 .       BFD_SEND (abfd, _bfd_find_line, \
1445 .                 (abfd, syms, sym, file, line))
1446 .
1447 .#define bfd_find_inliner_info(abfd, file, func, line) \
1448 .       BFD_SEND (abfd, _bfd_find_inliner_info, \
1449 .                 (abfd, file, func, line))
1450 .
1451 .#define bfd_debug_info_start(abfd) \
1452 .       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1453 .
1454 .#define bfd_debug_info_end(abfd) \
1455 .       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1456 .
1457 .#define bfd_debug_info_accumulate(abfd, section) \
1458 .       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1459 .
1460 .#define bfd_stat_arch_elt(abfd, stat) \
1461 .       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1462 .
1463 .#define bfd_update_armap_timestamp(abfd) \
1464 .       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1465 .
1466 .#define bfd_set_arch_mach(abfd, arch, mach)\
1467 .       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1468 .
1469 .#define bfd_relax_section(abfd, section, link_info, again) \
1470 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1471 .
1472 .#define bfd_gc_sections(abfd, link_info) \
1473 .       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1474 .
1475 .#define bfd_lookup_section_flags(link_info, flag_info, section) \
1476 .       BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section))
1477 .
1478 .#define bfd_merge_sections(abfd, link_info) \
1479 .       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1480 .
1481 .#define bfd_is_group_section(abfd, sec) \
1482 .       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1483 .
1484 .#define bfd_discard_group(abfd, sec) \
1485 .       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1486 .
1487 .#define bfd_link_hash_table_create(abfd) \
1488 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1489 .
1490 .#define bfd_link_hash_table_free(abfd, hash) \
1491 .       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
1492 .
1493 .#define bfd_link_add_symbols(abfd, info) \
1494 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1495 .
1496 .#define bfd_link_just_syms(abfd, sec, info) \
1497 .       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1498 .
1499 .#define bfd_final_link(abfd, info) \
1500 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1501 .
1502 .#define bfd_free_cached_info(abfd) \
1503 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1504 .
1505 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1506 .       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1507 .
1508 .#define bfd_print_private_bfd_data(abfd, file)\
1509 .       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1510 .
1511 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1512 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1513 .
1514 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1515 .       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1516 .                                                   dyncount, dynsyms, ret))
1517 .
1518 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1519 .       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1520 .
1521 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1522 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1523 .
1524 .extern bfd_byte *bfd_get_relocated_section_contents
1525 .  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1526 .   bfd_boolean, asymbol **);
1527 .
1528
1529 */
1530
1531 bfd_byte *
1532 bfd_get_relocated_section_contents (bfd *abfd,
1533                                     struct bfd_link_info *link_info,
1534                                     struct bfd_link_order *link_order,
1535                                     bfd_byte *data,
1536                                     bfd_boolean relocatable,
1537                                     asymbol **symbols)
1538 {
1539   bfd *abfd2;
1540   bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1541                    bfd_byte *, bfd_boolean, asymbol **);
1542
1543   if (link_order->type == bfd_indirect_link_order)
1544     {
1545       abfd2 = link_order->u.indirect.section->owner;
1546       if (abfd2 == NULL)
1547         abfd2 = abfd;
1548     }
1549   else
1550     abfd2 = abfd;
1551
1552   fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1553
1554   return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1555 }
1556
1557 /* Record information about an ELF program header.  */
1558
1559 bfd_boolean
1560 bfd_record_phdr (bfd *abfd,
1561                  unsigned long type,
1562                  bfd_boolean flags_valid,
1563                  flagword flags,
1564                  bfd_boolean at_valid,
1565                  bfd_vma at,
1566                  bfd_boolean includes_filehdr,
1567                  bfd_boolean includes_phdrs,
1568                  unsigned int count,
1569                  asection **secs)
1570 {
1571   struct elf_segment_map *m, **pm;
1572   bfd_size_type amt;
1573
1574   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1575     return TRUE;
1576
1577   amt = sizeof (struct elf_segment_map);
1578   amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1579   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
1580   if (m == NULL)
1581     return FALSE;
1582
1583   m->p_type = type;
1584   m->p_flags = flags;
1585   m->p_paddr = at;
1586   m->p_flags_valid = flags_valid;
1587   m->p_paddr_valid = at_valid;
1588   m->includes_filehdr = includes_filehdr;
1589   m->includes_phdrs = includes_phdrs;
1590   m->count = count;
1591   if (count > 0)
1592     memcpy (m->sections, secs, count * sizeof (asection *));
1593
1594   for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next)
1595     ;
1596   *pm = m;
1597
1598   return TRUE;
1599 }
1600
1601 #ifdef BFD64
1602 /* Return true iff this target is 32-bit.  */
1603
1604 static bfd_boolean
1605 is32bit (bfd *abfd)
1606 {
1607   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1608     {
1609       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1610       return bed->s->elfclass == ELFCLASS32;
1611     }
1612
1613   /* For non-ELF targets, use architecture information.  */
1614   return bfd_arch_bits_per_address (abfd) <= 32;
1615 }
1616 #endif
1617
1618 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
1619    target's address size.  */
1620
1621 void
1622 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
1623 {
1624 #ifdef BFD64
1625   if (is32bit (abfd))
1626     {
1627       sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
1628       return;
1629     }
1630 #endif
1631   sprintf_vma (buf, value);
1632 }
1633
1634 void
1635 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
1636 {
1637 #ifdef BFD64
1638   if (is32bit (abfd))
1639     {
1640       fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
1641       return;
1642     }
1643 #endif
1644   fprintf_vma ((FILE *) stream, value);
1645 }
1646
1647 /*
1648 FUNCTION
1649         bfd_alt_mach_code
1650
1651 SYNOPSIS
1652         bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
1653
1654 DESCRIPTION
1655
1656         When more than one machine code number is available for the
1657         same machine type, this function can be used to switch between
1658         the preferred one (alternative == 0) and any others.  Currently,
1659         only ELF supports this feature, with up to two alternate
1660         machine codes.
1661 */
1662
1663 bfd_boolean
1664 bfd_alt_mach_code (bfd *abfd, int alternative)
1665 {
1666   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1667     {
1668       int code;
1669
1670       switch (alternative)
1671         {
1672         case 0:
1673           code = get_elf_backend_data (abfd)->elf_machine_code;
1674           break;
1675
1676         case 1:
1677           code = get_elf_backend_data (abfd)->elf_machine_alt1;
1678           if (code == 0)
1679             return FALSE;
1680           break;
1681
1682         case 2:
1683           code = get_elf_backend_data (abfd)->elf_machine_alt2;
1684           if (code == 0)
1685             return FALSE;
1686           break;
1687
1688         default:
1689           return FALSE;
1690         }
1691
1692       elf_elfheader (abfd)->e_machine = code;
1693
1694       return TRUE;
1695     }
1696
1697   return FALSE;
1698 }
1699
1700 /*
1701 FUNCTION
1702         bfd_emul_get_maxpagesize
1703
1704 SYNOPSIS
1705         bfd_vma bfd_emul_get_maxpagesize (const char *);
1706
1707 DESCRIPTION
1708         Returns the maximum page size, in bytes, as determined by
1709         emulation.
1710
1711 RETURNS
1712         Returns the maximum page size in bytes for ELF, 0 otherwise.
1713 */
1714
1715 bfd_vma
1716 bfd_emul_get_maxpagesize (const char *emul)
1717 {
1718   const bfd_target *target;
1719
1720   target = bfd_find_target (emul, NULL);
1721   if (target != NULL
1722       && target->flavour == bfd_target_elf_flavour)
1723     return xvec_get_elf_backend_data (target)->maxpagesize;
1724
1725   return 0;
1726 }
1727
1728 static void
1729 bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size,
1730                       int offset, const bfd_target *orig_target)
1731 {
1732   if (target->flavour == bfd_target_elf_flavour)
1733     {
1734       const struct elf_backend_data *bed;
1735
1736       bed = xvec_get_elf_backend_data (target);
1737       *((bfd_vma *) ((char *) bed + offset)) = size;
1738     }
1739
1740   if (target->alternative_target
1741       && target->alternative_target != orig_target)
1742     bfd_elf_set_pagesize (target->alternative_target, size, offset,
1743                           orig_target);
1744 }
1745
1746 /*
1747 FUNCTION
1748         bfd_emul_set_maxpagesize
1749
1750 SYNOPSIS
1751         void bfd_emul_set_maxpagesize (const char *, bfd_vma);
1752
1753 DESCRIPTION
1754         For ELF, set the maximum page size for the emulation.  It is
1755         a no-op for other formats.
1756
1757 */
1758
1759 void
1760 bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
1761 {
1762   const bfd_target *target;
1763
1764   target = bfd_find_target (emul, NULL);
1765   if (target)
1766     bfd_elf_set_pagesize (target, size,
1767                           offsetof (struct elf_backend_data,
1768                                     maxpagesize), target);
1769 }
1770
1771 /*
1772 FUNCTION
1773         bfd_emul_get_commonpagesize
1774
1775 SYNOPSIS
1776         bfd_vma bfd_emul_get_commonpagesize (const char *);
1777
1778 DESCRIPTION
1779         Returns the common page size, in bytes, as determined by
1780         emulation.
1781
1782 RETURNS
1783         Returns the common page size in bytes for ELF, 0 otherwise.
1784 */
1785
1786 bfd_vma
1787 bfd_emul_get_commonpagesize (const char *emul)
1788 {
1789   const bfd_target *target;
1790
1791   target = bfd_find_target (emul, NULL);
1792   if (target != NULL
1793       && target->flavour == bfd_target_elf_flavour)
1794     return xvec_get_elf_backend_data (target)->commonpagesize;
1795
1796   return 0;
1797 }
1798
1799 /*
1800 FUNCTION
1801         bfd_emul_set_commonpagesize
1802
1803 SYNOPSIS
1804         void bfd_emul_set_commonpagesize (const char *, bfd_vma);
1805
1806 DESCRIPTION
1807         For ELF, set the common page size for the emulation.  It is
1808         a no-op for other formats.
1809
1810 */
1811
1812 void
1813 bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)
1814 {
1815   const bfd_target *target;
1816
1817   target = bfd_find_target (emul, NULL);
1818   if (target)
1819     bfd_elf_set_pagesize (target, size,
1820                           offsetof (struct elf_backend_data,
1821                                     commonpagesize), target);
1822 }
1823
1824 /*
1825 FUNCTION
1826         bfd_demangle
1827
1828 SYNOPSIS
1829         char *bfd_demangle (bfd *, const char *, int);
1830
1831 DESCRIPTION
1832         Wrapper around cplus_demangle.  Strips leading underscores and
1833         other such chars that would otherwise confuse the demangler.
1834         If passed a g++ v3 ABI mangled name, returns a buffer allocated
1835         with malloc holding the demangled name.  Returns NULL otherwise
1836         and on memory alloc failure.
1837 */
1838
1839 char *
1840 bfd_demangle (bfd *abfd, const char *name, int options)
1841 {
1842   char *res, *alloc;
1843   const char *pre, *suf;
1844   size_t pre_len;
1845   bfd_boolean skip_lead;
1846
1847   skip_lead = (abfd != NULL
1848                && *name != '\0'
1849                && bfd_get_symbol_leading_char (abfd) == *name);
1850   if (skip_lead)
1851     ++name;
1852
1853   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
1854      or the MS PE format.  These formats have a number of leading '.'s
1855      on at least some symbols, so we remove all dots to avoid
1856      confusing the demangler.  */
1857   pre = name;
1858   while (*name == '.' || *name == '$')
1859     ++name;
1860   pre_len = name - pre;
1861
1862   /* Strip off @plt and suchlike too.  */
1863   alloc = NULL;
1864   suf = strchr (name, '@');
1865   if (suf != NULL)
1866     {
1867       alloc = (char *) bfd_malloc (suf - name + 1);
1868       if (alloc == NULL)
1869         return NULL;
1870       memcpy (alloc, name, suf - name);
1871       alloc[suf - name] = '\0';
1872       name = alloc;
1873     }
1874
1875   res = cplus_demangle (name, options);
1876
1877   if (alloc != NULL)
1878     free (alloc);
1879
1880   if (res == NULL)
1881     {
1882       if (skip_lead)
1883         {
1884           size_t len = strlen (pre) + 1;
1885           alloc = (char *) bfd_malloc (len);
1886           if (alloc == NULL)
1887             return NULL;
1888           memcpy (alloc, pre, len);
1889           return alloc;
1890         }
1891       return NULL;
1892     }
1893
1894   /* Put back any prefix or suffix.  */
1895   if (pre_len != 0 || suf != NULL)
1896     {
1897       size_t len;
1898       size_t suf_len;
1899       char *final;
1900
1901       len = strlen (res);
1902       if (suf == NULL)
1903         suf = res + len;
1904       suf_len = strlen (suf) + 1;
1905       final = (char *) bfd_malloc (pre_len + len + suf_len);
1906       if (final != NULL)
1907         {
1908           memcpy (final, pre, pre_len);
1909           memcpy (final + pre_len, res, len);
1910           memcpy (final + pre_len + len, suf, suf_len);
1911         }
1912       free (res);
1913       res = final;
1914     }
1915
1916   return res;
1917 }