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