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