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
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 place where we add to the section list.  *}
 115 .  struct bfd_section **section_tail;
 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 \f
 220 /* provide storage for subsystem, stack and heap data which may have been
 221    passed in on the command line.  Ld puts this data into a bfd_link_info
 222    struct which ultimately gets passed in to the bfd.  When it arrives, copy
 223    it to the following struct so that the data will be available in coffcode.h
 224    where it is needed.  The typedef's used are defined in bfd.h */
 225 \f
 226 /*
 227 SECTION
 228         Error reporting
 229
 230         Most BFD functions return nonzero on success (check their
 231         individual documentation for precise semantics).  On an error,
 232         they call <<bfd_set_error>> to set an error condition that callers
 233         can check by calling <<bfd_get_error>>.
 234         If that returns <<bfd_error_system_call>>, then check
 235         <<errno>>.
 236
 237         The easiest way to report a BFD error to the user is to
 238         use <<bfd_perror>>.
 239
 240 SUBSECTION
 241         Type <<bfd_error_type>>
 242
 243         The values returned by <<bfd_get_error>> are defined by the
 244         enumerated type <<bfd_error_type>>.
 245
 246 CODE_FRAGMENT
 247 .
 248 .typedef enum bfd_error
 249 .{
 250 .  bfd_error_no_error = 0,
 251 .  bfd_error_system_call,
 252 .  bfd_error_invalid_target,
 253 .  bfd_error_wrong_format,
 254 .  bfd_error_wrong_object_format,
 255 .  bfd_error_invalid_operation,
 256 .  bfd_error_no_memory,
 257 .  bfd_error_no_symbols,
 258 .  bfd_error_no_armap,
 259 .  bfd_error_no_more_archived_files,
 260 .  bfd_error_malformed_archive,
 261 .  bfd_error_file_not_recognized,
 262 .  bfd_error_file_ambiguously_recognized,
 263 .  bfd_error_no_contents,
 264 .  bfd_error_nonrepresentable_section,
 265 .  bfd_error_no_debug_section,
 266 .  bfd_error_bad_value,
 267 .  bfd_error_file_truncated,
 268 .  bfd_error_file_too_big,
 269 .  bfd_error_invalid_error_code
 270 .}
 271 .bfd_error_type;
 272 .
 273 */
 274
 275 static bfd_error_type bfd_error = bfd_error_no_error;
 276
 277 const char *const bfd_errmsgs[] =
 278 {
 279   N_("No error"),
 280   N_("System call error"),
 281   N_("Invalid bfd target"),
 282   N_("File in wrong format"),
 283   N_("Archive object file in wrong format"),
 284   N_("Invalid operation"),
 285   N_("Memory exhausted"),
 286   N_("No symbols"),
 287   N_("Archive has no index; run ranlib to add one"),
 288   N_("No more archived files"),
 289   N_("Malformed archive"),
 290   N_("File format not recognized"),
 291   N_("File format is ambiguous"),
 292   N_("Section has no contents"),
 293   N_("Nonrepresentable section on output"),
 294   N_("Symbol needs debug section which does not exist"),
 295   N_("Bad value"),
 296   N_("File truncated"),
 297   N_("File too big"),
 298   N_("#<Invalid error code>")
 299 };
 300
 301 /*
 302 FUNCTION
 303         bfd_get_error
 304
 305 SYNOPSIS
 306         bfd_error_type bfd_get_error (void);
 307
 308 DESCRIPTION
 309         Return the current BFD error condition.
 310 */
 311
 312 bfd_error_type
 313 bfd_get_error (void)
 314 {
 315   return bfd_error;
 316 }
 317
 318 /*
 319 FUNCTION
 320         bfd_set_error
 321
 322 SYNOPSIS
 323         void bfd_set_error (bfd_error_type error_tag);
 324
 325 DESCRIPTION
 326         Set the BFD error condition to be @var{error_tag}.
 327 */
 328
 329 void
 330 bfd_set_error (bfd_error_type error_tag)
 331 {
 332   bfd_error = error_tag;
 333 }
 334
 335 /*
 336 FUNCTION
 337         bfd_errmsg
 338
 339 SYNOPSIS
 340         const char *bfd_errmsg (bfd_error_type error_tag);
 341
 342 DESCRIPTION
 343         Return a string describing the error @var{error_tag}, or
 344         the system error if @var{error_tag} is <<bfd_error_system_call>>.
 345 */
 346
 347 const char *
 348 bfd_errmsg (bfd_error_type error_tag)
 349 {
 350 #ifndef errno
 351   extern int errno;
 352 #endif
 353   if (error_tag == bfd_error_system_call)
 354     return xstrerror (errno);
 355
 356   if (error_tag > bfd_error_invalid_error_code)
 357     error_tag = bfd_error_invalid_error_code;   /* sanity check */
 358
 359   return _(bfd_errmsgs [error_tag]);
 360 }
 361
 362 /*
 363 FUNCTION
 364         bfd_perror
 365
 366 SYNOPSIS
 367         void bfd_perror (const char *message);
 368
 369 DESCRIPTION
 370         Print to the standard error stream a string describing the
 371         last BFD error that occurred, or the last system error if
 372         the last BFD error was a system call failure.  If @var{message}
 373         is non-NULL and non-empty, the error string printed is preceded
 374         by @var{message}, a colon, and a space.  It is followed by a newline.
 375 */
 376
 377 void
 378 bfd_perror (const char *message)
 379 {
 380   if (bfd_get_error () == bfd_error_system_call)
 381     /* Must be a system error then.  */
 382     perror ((char *) message);
 383   else
 384     {
 385       if (message == NULL || *message == '\0')
 386         fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
 387       else
 388         fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
 389     }
 390 }
 391
 392 /*
 393 SUBSECTION
 394         BFD error handler
 395
 396         Some BFD functions want to print messages describing the
 397         problem.  They call a BFD error handler function.  This
 398         function may be overridden by the program.
 399
 400         The BFD error handler acts like printf.
 401
 402 CODE_FRAGMENT
 403 .
 404 .typedef void (*bfd_error_handler_type) (const char *, ...);
 405 .
 406 */
 407
 408 /* The program name used when printing BFD error messages.  */
 409
 410 static const char *_bfd_error_program_name;
 411
 412 /* This is the default routine to handle BFD error messages.
 413    Like fprintf (stderr, ...), but also handles some extra format specifiers.
 414
 415    %A section name from section.  For group components, print group name too.
 416    %B file name from bfd.  For archive components, prints archive too.
 417  */
 418
 419 void
 420 _bfd_default_error_handler (const char *fmt, ...)
 421 {
 422   va_list ap;
 423   char *bufp;
 424   const char *new_fmt, *p;
 425   size_t avail = 1000;
 426   char buf[1000];
 427
 428   if (_bfd_error_program_name != NULL)
 429     fprintf (stderr, "%s: ", _bfd_error_program_name);
 430   else
 431     fprintf (stderr, "BFD: ");
 432
 433   va_start (ap, fmt);
 434   new_fmt = fmt;
 435   bufp = buf;
 436
 437   /* Reserve enough space for the existing format string.  */
 438   avail -= strlen (fmt) + 1;
 439   if (avail > 1000)
 440     abort ();
 441
 442   p = fmt;
 443   while (1)
 444     {
 445       char *q;
 446       size_t len, extra, trim;
 447
 448       p = strchr (p, '%');
 449       if (p == NULL || p[1] == '\0')
 450         {
 451           if (new_fmt == buf)
 452             {
 453               len = strlen (fmt);
 454               memcpy (bufp, fmt, len + 1);
 455             }
 456           break;
 457         }
 458
 459       if (p[1] == 'A' || p[1] == 'B')
 460         {
 461           len = p - fmt;
 462           memcpy (bufp, fmt, len);
 463           bufp += len;
 464           fmt = p + 2;
 465           new_fmt = buf;
 466
 467           /* If we run out of space, tough, you lose your ridiculously
 468              long file or section name.  It's not safe to try to alloc
 469              memory here;  We might be printing an out of memory message.  */
 470           if (avail == 0)
 471             {
 472               *bufp++ = '*';
 473               *bufp++ = '*';
 474               *bufp = '\0';
 475             }
 476           else
 477             {
 478               if (p[1] == 'B')
 479                 {
 480                   bfd *abfd = va_arg (ap, bfd *);
 481                   if (abfd->my_archive)
 482                     snprintf (bufp, avail, "%s(%s)",
 483                               abfd->my_archive->filename, abfd->filename);
 484                   else
 485                     snprintf (bufp, avail, "%s", abfd->filename);
 486                 }
 487               else
 488                 {
 489                   asection *sec = va_arg (ap, asection *);
 490                   bfd *abfd = sec->owner;
 491                   const char *group = NULL;
 492                   struct coff_comdat_info *ci;
 493
 494                   if (abfd != NULL
 495                       && bfd_get_flavour (abfd) == bfd_target_elf_flavour
 496                       && elf_next_in_group (sec) != NULL
 497                       && (sec->flags & SEC_GROUP) == 0)
 498                     group = elf_group_name (sec);
 499                   else if (abfd != NULL
 500                            && bfd_get_flavour (abfd) == bfd_target_coff_flavour
 501                            && (ci = bfd_coff_get_comdat_section (sec->owner,
 502                                                                  sec)) != NULL)
 503                     group = ci->name;
 504                   if (group != NULL)
 505                     snprintf (bufp, avail, "%s[%s]", sec->name, group);
 506                   else
 507                     snprintf (bufp, avail, "%s", sec->name);
 508                 }
 509               len = strlen (bufp);
 510               avail = avail - len + 2;
 511
 512               /* We need to replace any '%' we printed by "%%".
 513                  First count how many.  */
 514               q = bufp;
 515               bufp += len;
 516               extra = 0;
 517               while ((q = strchr (q, '%')) != NULL)
 518                 {
 519                   ++q;
 520                   ++extra;
 521                 }
 522
 523               /* If there isn't room, trim off the end of the string.  */
 524               q = bufp;
 525               bufp += extra;
 526               if (extra > avail)
 527                 {
 528                   trim = extra - avail;
 529                   bufp -= trim;
 530                   do
 531                     {
 532                       if (*--q == '%')
 533                         --extra;
 534                     }
 535                   while (--trim != 0);
 536                   *q = '\0';
 537                   avail = extra;
 538                 }
 539               avail -= extra;
 540
 541               /* Now double all '%' chars, shuffling the string as we go.  */
 542               while (extra != 0)
 543                 {
 544                   while ((q[extra] = *q) != '%')
 545                     --q;
 546                   q[--extra] = '%';
 547                   --q;
 548                 }
 549             }
 550         }
 551       p = p + 2;
 552     }
 553
 554   vfprintf (stderr, new_fmt, ap);
 555   va_end (ap);
 556
 557   putc ('\n', stderr);
 558 }
 559
 560 /* This is a function pointer to the routine which should handle BFD
 561    error messages.  It is called when a BFD routine encounters an
 562    error for which it wants to print a message.  Going through a
 563    function pointer permits a program linked against BFD to intercept
 564    the messages and deal with them itself.  */
 565
 566 bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler;
 567
 568 /*
 569 FUNCTION
 570         bfd_set_error_handler
 571
 572 SYNOPSIS
 573         bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
 574
 575 DESCRIPTION
 576         Set the BFD error handler function.  Returns the previous
 577         function.
 578 */
 579
 580 bfd_error_handler_type
 581 bfd_set_error_handler (bfd_error_handler_type pnew)
 582 {
 583   bfd_error_handler_type pold;
 584
 585   pold = _bfd_error_handler;
 586   _bfd_error_handler = pnew;
 587   return pold;
 588 }
 589
 590 /*
 591 FUNCTION
 592         bfd_set_error_program_name
 593
 594 SYNOPSIS
 595         void bfd_set_error_program_name (const char *);
 596
 597 DESCRIPTION
 598         Set the program name to use when printing a BFD error.  This
 599         is printed before the error message followed by a colon and
 600         space.  The string must not be changed after it is passed to
 601         this function.
 602 */
 603
 604 void
 605 bfd_set_error_program_name (const char *name)
 606 {
 607   _bfd_error_program_name = name;
 608 }
 609
 610 /*
 611 FUNCTION
 612         bfd_get_error_handler
 613
 614 SYNOPSIS
 615         bfd_error_handler_type bfd_get_error_handler (void);
 616
 617 DESCRIPTION
 618         Return the BFD error handler function.
 619 */
 620
 621 bfd_error_handler_type
 622 bfd_get_error_handler (void)
 623 {
 624   return _bfd_error_handler;
 625 }
 626 \f
 627 /*
 628 SECTION
 629         Symbols
 630 */
 631
 632 /*
 633 FUNCTION
 634         bfd_get_reloc_upper_bound
 635
 636 SYNOPSIS
 637         long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
 638
 639 DESCRIPTION
 640         Return the number of bytes required to store the
 641         relocation information associated with section @var{sect}
 642         attached to bfd @var{abfd}.  If an error occurs, return -1.
 643
 644 */
 645
 646 long
 647 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
 648 {
 649   if (abfd->format != bfd_object)
 650     {
 651       bfd_set_error (bfd_error_invalid_operation);
 652       return -1;
 653     }
 654
 655   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 656 }
 657
 658 /*
 659 FUNCTION
 660         bfd_canonicalize_reloc
 661
 662 SYNOPSIS
 663         long bfd_canonicalize_reloc
 664           (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
 665
 666 DESCRIPTION
 667         Call the back end associated with the open BFD
 668         @var{abfd} and translate the external form of the relocation
 669         information attached to @var{sec} into the internal canonical
 670         form.  Place the table into memory at @var{loc}, which has
 671         been preallocated, usually by a call to
 672         <<bfd_get_reloc_upper_bound>>.  Returns the number of relocs, or
 673         -1 on error.
 674
 675         The @var{syms} table is also needed for horrible internal magic
 676         reasons.
 677
 678 */
 679 long
 680 bfd_canonicalize_reloc (bfd *abfd,
 681                         sec_ptr asect,
 682                         arelent **location,
 683                         asymbol **symbols)
 684 {
 685   if (abfd->format != bfd_object)
 686     {
 687       bfd_set_error (bfd_error_invalid_operation);
 688       return -1;
 689     }
 690
 691   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
 692                    (abfd, asect, location, symbols));
 693 }
 694
 695 /*
 696 FUNCTION
 697         bfd_set_reloc
 698
 699 SYNOPSIS
 700         void bfd_set_reloc
 701           (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
 702
 703 DESCRIPTION
 704         Set the relocation pointer and count within
 705         section @var{sec} to the values @var{rel} and @var{count}.
 706         The argument @var{abfd} is ignored.
 707
 708 */
 709
 710 void
 711 bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED,
 712                sec_ptr asect,
 713                arelent **location,
 714                unsigned int count)
 715 {
 716   asect->orelocation = location;
 717   asect->reloc_count = count;
 718 }
 719
 720 /*
 721 FUNCTION
 722         bfd_set_file_flags
 723
 724 SYNOPSIS
 725         bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
 726
 727 DESCRIPTION
 728         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
 729
 730         Possible errors are:
 731         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
 732         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
 733         o <<bfd_error_invalid_operation>> -
 734         The flag word contained a bit which was not applicable to the
 735         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
 736         on a BFD format which does not support demand paging.
 737
 738 */
 739
 740 bfd_boolean
 741 bfd_set_file_flags (bfd *abfd, flagword flags)
 742 {
 743   if (abfd->format != bfd_object)
 744     {
 745       bfd_set_error (bfd_error_wrong_format);
 746       return FALSE;
 747     }
 748
 749   if (bfd_read_p (abfd))
 750     {
 751       bfd_set_error (bfd_error_invalid_operation);
 752       return FALSE;
 753     }
 754
 755   bfd_get_file_flags (abfd) = flags;
 756   if ((flags & bfd_applicable_file_flags (abfd)) != flags)
 757     {
 758       bfd_set_error (bfd_error_invalid_operation);
 759       return FALSE;
 760     }
 761
 762   return TRUE;
 763 }
 764
 765 void
 766 bfd_assert (const char *file, int line)
 767 {
 768   (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"),
 769                          BFD_VERSION_STRING, file, line);
 770 }
 771
 772 /* A more or less friendly abort message.  In libbfd.h abort is
 773    defined to call this function.  */
 774
 775 #ifndef EXIT_FAILURE
 776 #define EXIT_FAILURE 1
 777 #endif
 778
 779 void
 780 _bfd_abort (const char *file, int line, const char *fn)
 781 {
 782   if (fn != NULL)
 783     (*_bfd_error_handler)
 784       (_("BFD %s internal error, aborting at %s line %d in %s\n"),
 785        BFD_VERSION_STRING, file, line, fn);
 786   else
 787     (*_bfd_error_handler)
 788       (_("BFD %s internal error, aborting at %s line %d\n"),
 789        BFD_VERSION_STRING, file, line);
 790   (*_bfd_error_handler) (_("Please report this bug.\n"));
 791   xexit (EXIT_FAILURE);
 792 }
 793
 794 /*
 795 FUNCTION
 796         bfd_get_arch_size
 797
 798 SYNOPSIS
 799         int bfd_get_arch_size (bfd *abfd);
 800
 801 DESCRIPTION
 802         Returns the architecture address size, in bits, as determined
 803         by the object file's format.  For ELF, this information is
 804         included in the header.
 805
 806 RETURNS
 807         Returns the arch size in bits if known, <<-1>> otherwise.
 808 */
 809
 810 int
 811 bfd_get_arch_size (bfd *abfd)
 812 {
 813   if (abfd->xvec->flavour == bfd_target_elf_flavour)
 814     return get_elf_backend_data (abfd)->s->arch_size;
 815
 816   return -1;
 817 }
 818
 819 /*
 820 FUNCTION
 821         bfd_get_sign_extend_vma
 822
 823 SYNOPSIS
 824         int bfd_get_sign_extend_vma (bfd *abfd);
 825
 826 DESCRIPTION
 827         Indicates if the target architecture "naturally" sign extends
 828         an address.  Some architectures implicitly sign extend address
 829         values when they are converted to types larger than the size
 830         of an address.  For instance, bfd_get_start_address() will
 831         return an address sign extended to fill a bfd_vma when this is
 832         the case.
 833
 834 RETURNS
 835         Returns <<1>> if the target architecture is known to sign
 836         extend addresses, <<0>> if the target architecture is known to
 837         not sign extend addresses, and <<-1>> otherwise.
 838 */
 839
 840 int
 841 bfd_get_sign_extend_vma (bfd *abfd)
 842 {
 843   char *name;
 844
 845   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 846     return get_elf_backend_data (abfd)->sign_extend_vma;
 847
 848   name = bfd_get_target (abfd);
 849
 850   /* Return a proper value for DJGPP & PE COFF (x86 COFF variants).
 851      This function is required for DWARF2 support, but there is
 852      no place to store this information in the COFF back end.
 853      Should enough other COFF targets add support for DWARF2,
 854      a place will have to be found.  Until then, this hack will do.  */
 855   if (strncmp (name, "coff-go32", sizeof ("coff-go32") - 1) == 0
 856       || strcmp (name, "pe-i386") == 0
 857       || strcmp (name, "pei-i386") == 0)
 858     return 1;
 859
 860   bfd_set_error (bfd_error_wrong_format);
 861   return -1;
 862 }
 863
 864 /*
 865 FUNCTION
 866         bfd_set_start_address
 867
 868 SYNOPSIS
 869         bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
 870
 871 DESCRIPTION
 872         Make @var{vma} the entry point of output BFD @var{abfd}.
 873
 874 RETURNS
 875         Returns <<TRUE>> on success, <<FALSE>> otherwise.
 876 */
 877
 878 bfd_boolean
 879 bfd_set_start_address (bfd *abfd, bfd_vma vma)
 880 {
 881   abfd->start_address = vma;
 882   return TRUE;
 883 }
 884
 885 /*
 886 FUNCTION
 887         bfd_get_gp_size
 888
 889 SYNOPSIS
 890         unsigned int bfd_get_gp_size (bfd *abfd);
 891
 892 DESCRIPTION
 893         Return the maximum size of objects to be optimized using the GP
 894         register under MIPS ECOFF.  This is typically set by the <<-G>>
 895         argument to the compiler, assembler or linker.
 896 */
 897
 898 unsigned int
 899 bfd_get_gp_size (bfd *abfd)
 900 {
 901   if (abfd->format == bfd_object)
 902     {
 903       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 904         return ecoff_data (abfd)->gp_size;
 905       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 906         return elf_gp_size (abfd);
 907     }
 908   return 0;
 909 }
 910
 911 /*
 912 FUNCTION
 913         bfd_set_gp_size
 914
 915 SYNOPSIS
 916         void bfd_set_gp_size (bfd *abfd, unsigned int i);
 917
 918 DESCRIPTION
 919         Set the maximum size of objects to be optimized using the GP
 920         register under ECOFF or MIPS ELF.  This is typically set by
 921         the <<-G>> argument to the compiler, assembler or linker.
 922 */
 923
 924 void
 925 bfd_set_gp_size (bfd *abfd, unsigned int i)
 926 {
 927   /* Don't try to set GP size on an archive or core file!  */
 928   if (abfd->format != bfd_object)
 929     return;
 930
 931   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 932     ecoff_data (abfd)->gp_size = i;
 933   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 934     elf_gp_size (abfd) = i;
 935 }
 936
 937 /* Get the GP value.  This is an internal function used by some of the
 938    relocation special_function routines on targets which support a GP
 939    register.  */
 940
 941 bfd_vma
 942 _bfd_get_gp_value (bfd *abfd)
 943 {
 944   if (! abfd)
 945     return 0;
 946   if (abfd->format != bfd_object)
 947     return 0;
 948
 949   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 950     return ecoff_data (abfd)->gp;
 951   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 952     return elf_gp (abfd);
 953
 954   return 0;
 955 }
 956
 957 /* Set the GP value.  */
 958
 959 void
 960 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
 961 {
 962   if (! abfd)
 963     BFD_FAIL ();
 964   if (abfd->format != bfd_object)
 965     return;
 966
 967   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 968     ecoff_data (abfd)->gp = v;
 969   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 970     elf_gp (abfd) = v;
 971 }
 972
 973 /*
 974 FUNCTION
 975         bfd_scan_vma
 976
 977 SYNOPSIS
 978         bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
 979
 980 DESCRIPTION
 981         Convert, like <<strtoul>>, a numerical expression
 982         @var{string} into a <<bfd_vma>> integer, and return that integer.
 983         (Though without as many bells and whistles as <<strtoul>>.)
 984         The expression is assumed to be unsigned (i.e., positive).
 985         If given a @var{base}, it is used as the base for conversion.
 986         A base of 0 causes the function to interpret the string
 987         in hex if a leading "0x" or "0X" is found, otherwise
 988         in octal if a leading zero is found, otherwise in decimal.
 989
 990         If the value would overflow, the maximum <<bfd_vma>> value is
 991         returned.
 992 */
 993
 994 bfd_vma
 995 bfd_scan_vma (const char *string, const char **end, int base)
 996 {
 997   bfd_vma value;
 998   bfd_vma cutoff;
 999   unsigned int cutlim;
1000   int overflow;
1001
1002   /* Let the host do it if possible.  */
1003   if (sizeof (bfd_vma) <= sizeof (unsigned long))
1004     return strtoul (string, (char **) end, base);
1005
1006 #ifdef HAVE_STRTOULL
1007   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1008     return strtoull (string, (char **) end, base);
1009 #endif
1010
1011   if (base == 0)
1012     {
1013       if (string[0] == '0')
1014         {
1015           if ((string[1] == 'x') || (string[1] == 'X'))
1016             base = 16;
1017           else
1018             base = 8;
1019         }
1020     }
1021
1022   if ((base < 2) || (base > 36))
1023     base = 10;
1024
1025   if (base == 16
1026       && string[0] == '0'
1027       && (string[1] == 'x' || string[1] == 'X')
1028       && ISXDIGIT (string[2]))
1029     {
1030       string += 2;
1031     }
1032
1033   cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1034   cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1035   value = 0;
1036   overflow = 0;
1037   while (1)
1038     {
1039       unsigned int digit;
1040
1041       digit = *string;
1042       if (ISDIGIT (digit))
1043         digit = digit - '0';
1044       else if (ISALPHA (digit))
1045         digit = TOUPPER (digit) - 'A' + 10;
1046       else
1047         break;
1048       if (digit >= (unsigned int) base)
1049         break;
1050       if (value > cutoff || (value == cutoff && digit > cutlim))
1051         overflow = 1;
1052       value = value * base + digit;
1053       ++string;
1054     }
1055
1056   if (overflow)
1057     value = ~ (bfd_vma) 0;
1058
1059   if (end != NULL)
1060     *end = string;
1061
1062   return value;
1063 }
1064
1065 /*
1066 FUNCTION
1067         bfd_copy_private_header_data
1068
1069 SYNOPSIS
1070         bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1071
1072 DESCRIPTION
1073         Copy private BFD header information from the BFD @var{ibfd} to the
1074         the BFD @var{obfd}.  This copies information that may require
1075         sections to exist, but does not require symbol tables.  Return
1076         <<true>> on success, <<false>> on error.
1077         Possible error returns are:
1078
1079         o <<bfd_error_no_memory>> -
1080         Not enough memory exists to create private data for @var{obfd}.
1081
1082 .#define bfd_copy_private_header_data(ibfd, obfd) \
1083 .     BFD_SEND (obfd, _bfd_copy_private_header_data, \
1084 .               (ibfd, obfd))
1085
1086 */
1087
1088 /*
1089 FUNCTION
1090         bfd_copy_private_bfd_data
1091
1092 SYNOPSIS
1093         bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1094
1095 DESCRIPTION
1096         Copy private BFD information from the BFD @var{ibfd} to the
1097         the BFD @var{obfd}.  Return <<TRUE>> on success, <<FALSE>> on error.
1098         Possible error returns are:
1099
1100         o <<bfd_error_no_memory>> -
1101         Not enough memory exists to create private data for @var{obfd}.
1102
1103 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1104 .     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1105 .               (ibfd, obfd))
1106
1107 */
1108
1109 /*
1110 FUNCTION
1111         bfd_merge_private_bfd_data
1112
1113 SYNOPSIS
1114         bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
1115
1116 DESCRIPTION
1117         Merge private BFD information from the BFD @var{ibfd} to the
1118         the output file BFD @var{obfd} when linking.  Return <<TRUE>>
1119         on success, <<FALSE>> on error.  Possible error returns are:
1120
1121         o <<bfd_error_no_memory>> -
1122         Not enough memory exists to create private data for @var{obfd}.
1123
1124 .#define bfd_merge_private_bfd_data(ibfd, obfd) \
1125 .     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1126 .               (ibfd, obfd))
1127
1128 */
1129
1130 /*
1131 FUNCTION
1132         bfd_set_private_flags
1133
1134 SYNOPSIS
1135         bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1136
1137 DESCRIPTION
1138         Set private BFD flag information in the BFD @var{abfd}.
1139         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
1140         returns are:
1141
1142         o <<bfd_error_no_memory>> -
1143         Not enough memory exists to create private data for @var{obfd}.
1144
1145 .#define bfd_set_private_flags(abfd, flags) \
1146 .     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1147
1148 */
1149
1150 /*
1151 FUNCTION
1152         Other functions
1153
1154 DESCRIPTION
1155         The following functions exist but have not yet been documented.
1156
1157 .#define bfd_sizeof_headers(abfd, reloc) \
1158 .       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
1159 .
1160 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1161 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
1162 .                 (abfd, sec, syms, off, file, func, line))
1163 .
1164 .#define bfd_debug_info_start(abfd) \
1165 .       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1166 .
1167 .#define bfd_debug_info_end(abfd) \
1168 .       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1169 .
1170 .#define bfd_debug_info_accumulate(abfd, section) \
1171 .       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1172 .
1173 .#define bfd_stat_arch_elt(abfd, stat) \
1174 .       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1175 .
1176 .#define bfd_update_armap_timestamp(abfd) \
1177 .       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1178 .
1179 .#define bfd_set_arch_mach(abfd, arch, mach)\
1180 .       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1181 .
1182 .#define bfd_relax_section(abfd, section, link_info, again) \
1183 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1184 .
1185 .#define bfd_gc_sections(abfd, link_info) \
1186 .       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1187 .
1188 .#define bfd_merge_sections(abfd, link_info) \
1189 .       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1190 .
1191 .#define bfd_is_group_section(abfd, sec) \
1192 .       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1193 .
1194 .#define bfd_discard_group(abfd, sec) \
1195 .       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1196 .
1197 .#define bfd_link_hash_table_create(abfd) \
1198 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1199 .
1200 .#define bfd_link_hash_table_free(abfd, hash) \
1201 .       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
1202 .
1203 .#define bfd_link_add_symbols(abfd, info) \
1204 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1205 .
1206 .#define bfd_link_just_syms(sec, info) \
1207 .       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1208 .
1209 .#define bfd_final_link(abfd, info) \
1210 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1211 .
1212 .#define bfd_free_cached_info(abfd) \
1213 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1214 .
1215 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1216 .       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1217 .
1218 .#define bfd_print_private_bfd_data(abfd, file)\
1219 .       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1220 .
1221 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1222 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1223 .
1224 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1225 .       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1226 .                                                   dyncount, dynsyms, ret))
1227 .
1228 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1229 .       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1230 .
1231 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1232 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1233 .
1234 .extern bfd_byte *bfd_get_relocated_section_contents
1235 .  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1236 .   bfd_boolean, asymbol **);
1237 .
1238
1239 */
1240
1241 bfd_byte *
1242 bfd_get_relocated_section_contents (bfd *abfd,
1243                                     struct bfd_link_info *link_info,
1244                                     struct bfd_link_order *link_order,
1245                                     bfd_byte *data,
1246                                     bfd_boolean relocatable,
1247                                     asymbol **symbols)
1248 {
1249   bfd *abfd2;
1250   bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1251                    bfd_byte *, bfd_boolean, asymbol **);
1252
1253   if (link_order->type == bfd_indirect_link_order)
1254     {
1255       abfd2 = link_order->u.indirect.section->owner;
1256       if (abfd2 == NULL)
1257         abfd2 = abfd;
1258     }
1259   else
1260     abfd2 = abfd;
1261
1262   fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1263
1264   return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1265 }
1266
1267 /* Record information about an ELF program header.  */
1268
1269 bfd_boolean
1270 bfd_record_phdr (bfd *abfd,
1271                  unsigned long type,
1272                  bfd_boolean flags_valid,
1273                  flagword flags,
1274                  bfd_boolean at_valid,
1275                  bfd_vma at,
1276                  bfd_boolean includes_filehdr,
1277                  bfd_boolean includes_phdrs,
1278                  unsigned int count,
1279                  asection **secs)
1280 {
1281   struct elf_segment_map *m, **pm;
1282   bfd_size_type amt;
1283
1284   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1285     return TRUE;
1286
1287   amt = sizeof (struct elf_segment_map);
1288   amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1289   m = bfd_alloc (abfd, amt);
1290   if (m == NULL)
1291     return FALSE;
1292
1293   m->next = NULL;
1294   m->p_type = type;
1295   m->p_flags = flags;
1296   m->p_paddr = at;
1297   m->p_flags_valid = flags_valid;
1298   m->p_paddr_valid = at_valid;
1299   m->includes_filehdr = includes_filehdr;
1300   m->includes_phdrs = includes_phdrs;
1301   m->count = count;
1302   if (count > 0)
1303     memcpy (m->sections, secs, count * sizeof (asection *));
1304
1305   for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
1306     ;
1307   *pm = m;
1308
1309   return TRUE;
1310 }
1311
1312 void
1313 bfd_sprintf_vma (bfd *abfd, char *buf, bfd_vma value)
1314 {
1315   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1316     get_elf_backend_data (abfd)->elf_backend_sprintf_vma (abfd, buf, value);
1317   else
1318     sprintf_vma (buf, value);
1319 }
1320
1321 void
1322 bfd_fprintf_vma (bfd *abfd, void *stream, bfd_vma value)
1323 {
1324   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1325     get_elf_backend_data (abfd)->elf_backend_fprintf_vma (abfd, stream, value);
1326   else
1327     fprintf_vma ((FILE *) stream, value);
1328 }
1329
1330 /*
1331 FUNCTION
1332         bfd_alt_mach_code
1333
1334 SYNOPSIS
1335         bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
1336
1337 DESCRIPTION
1338
1339         When more than one machine code number is available for the
1340         same machine type, this function can be used to switch between
1341         the preferred one (alternative == 0) and any others.  Currently,
1342         only ELF supports this feature, with up to two alternate
1343         machine codes.
1344 */
1345
1346 bfd_boolean
1347 bfd_alt_mach_code (bfd *abfd, int alternative)
1348 {
1349   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1350     {
1351       int code;
1352
1353       switch (alternative)
1354         {
1355         case 0:
1356           code = get_elf_backend_data (abfd)->elf_machine_code;
1357           break;
1358
1359         case 1:
1360           code = get_elf_backend_data (abfd)->elf_machine_alt1;
1361           if (code == 0)
1362             return FALSE;
1363           break;
1364
1365         case 2:
1366           code = get_elf_backend_data (abfd)->elf_machine_alt2;
1367           if (code == 0)
1368             return FALSE;
1369           break;
1370
1371         default:
1372           return FALSE;
1373         }
1374
1375       elf_elfheader (abfd)->e_machine = code;
1376
1377       return TRUE;
1378     }
1379
1380   return FALSE;
1381 }
1382
1383 /*
1384 CODE_FRAGMENT
1385
1386 .struct bfd_preserve
1387 .{
1388 .  void *marker;
1389 .  void *tdata;
1390 .  flagword flags;
1391 .  const struct bfd_arch_info *arch_info;
1392 .  struct bfd_section *sections;
1393 .  struct bfd_section **section_tail;
1394 .  unsigned int section_count;
1395 .  struct bfd_hash_table section_htab;
1396 .};
1397 .
1398 */
1399
1400 /*
1401 FUNCTION
1402         bfd_preserve_save
1403
1404 SYNOPSIS
1405         bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);
1406
1407 DESCRIPTION
1408         When testing an object for compatibility with a particular
1409         target back-end, the back-end object_p function needs to set
1410         up certain fields in the bfd on successfully recognizing the
1411         object.  This typically happens in a piecemeal fashion, with
1412         failures possible at many points.  On failure, the bfd is
1413         supposed to be restored to its initial state, which is
1414         virtually impossible.  However, restoring a subset of the bfd
1415         state works in practice.  This function stores the subset and
1416         reinitializes the bfd.
1417
1418 */
1419
1420 bfd_boolean
1421 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
1422 {
1423   preserve->tdata = abfd->tdata.any;
1424   preserve->arch_info = abfd->arch_info;
1425   preserve->flags = abfd->flags;
1426   preserve->sections = abfd->sections;
1427   preserve->section_tail = abfd->section_tail;
1428   preserve->section_count = abfd->section_count;
1429   preserve->section_htab = abfd->section_htab;
1430
1431   if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc))
1432     return FALSE;
1433
1434   abfd->tdata.any = NULL;
1435   abfd->arch_info = &bfd_default_arch_struct;
1436   abfd->flags &= BFD_IN_MEMORY;
1437   abfd->sections = NULL;
1438   abfd->section_tail = &abfd->sections;
1439   abfd->section_count = 0;
1440
1441   return TRUE;
1442 }
1443
1444 /*
1445 FUNCTION
1446         bfd_preserve_restore
1447
1448 SYNOPSIS
1449         void bfd_preserve_restore (bfd *, struct bfd_preserve *);
1450
1451 DESCRIPTION
1452         This function restores bfd state saved by bfd_preserve_save.
1453         If MARKER is non-NULL in struct bfd_preserve then that block
1454         and all subsequently bfd_alloc'd memory is freed.
1455
1456 */
1457
1458 void
1459 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
1460 {
1461   bfd_hash_table_free (&abfd->section_htab);
1462
1463   abfd->tdata.any = preserve->tdata;
1464   abfd->arch_info = preserve->arch_info;
1465   abfd->flags = preserve->flags;
1466   abfd->section_htab = preserve->section_htab;
1467   abfd->sections = preserve->sections;
1468   abfd->section_tail = preserve->section_tail;
1469   abfd->section_count = preserve->section_count;
1470
1471   /* bfd_release frees all memory more recently bfd_alloc'd than
1472      its arg, as well as its arg.  */
1473   if (preserve->marker != NULL)
1474     {
1475       bfd_release (abfd, preserve->marker);
1476       preserve->marker = NULL;
1477     }
1478 }
1479
1480 /*
1481 FUNCTION
1482         bfd_preserve_finish
1483
1484 SYNOPSIS
1485         void bfd_preserve_finish (bfd *, struct bfd_preserve *);
1486
1487 DESCRIPTION
1488         This function should be called when the bfd state saved by
1489         bfd_preserve_save is no longer needed.  ie. when the back-end
1490         object_p function returns with success.
1491
1492 */
1493
1494 void
1495 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
1496 {
1497   /* It would be nice to be able to free more memory here, eg. old
1498      tdata, but that's not possible since these blocks are sitting
1499      inside bfd_alloc'd memory.  The section hash is on a separate
1500      objalloc.  */
1501   bfd_hash_table_free (&preserve->section_htab);
1502 }