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