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