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
   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 \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         Miscellaneous
 630
 631 SUBSECTION
 632         Miscellaneous functions
 633 */
 634
 635 /*
 636 FUNCTION
 637         bfd_get_reloc_upper_bound
 638
 639 SYNOPSIS
 640         long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
 641
 642 DESCRIPTION
 643         Return the number of bytes required to store the
 644         relocation information associated with section @var{sect}
 645         attached to bfd @var{abfd}.  If an error occurs, return -1.
 646
 647 */
 648
 649 long
 650 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
 651 {
 652   if (abfd->format != bfd_object)
 653     {
 654       bfd_set_error (bfd_error_invalid_operation);
 655       return -1;
 656     }
 657
 658   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 659 }
 660
 661 /*
 662 FUNCTION
 663         bfd_canonicalize_reloc
 664
 665 SYNOPSIS
 666         long bfd_canonicalize_reloc
 667           (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
 668
 669 DESCRIPTION
 670         Call the back end associated with the open BFD
 671         @var{abfd} and translate the external form of the relocation
 672         information attached to @var{sec} into the internal canonical
 673         form.  Place the table into memory at @var{loc}, which has
 674         been preallocated, usually by a call to
 675         <<bfd_get_reloc_upper_bound>>.  Returns the number of relocs, or
 676         -1 on error.
 677
 678         The @var{syms} table is also needed for horrible internal magic
 679         reasons.
 680
 681 */
 682 long
 683 bfd_canonicalize_reloc (bfd *abfd,
 684                         sec_ptr asect,
 685                         arelent **location,
 686                         asymbol **symbols)
 687 {
 688   if (abfd->format != bfd_object)
 689     {
 690       bfd_set_error (bfd_error_invalid_operation);
 691       return -1;
 692     }
 693
 694   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
 695                    (abfd, asect, location, symbols));
 696 }
 697
 698 /*
 699 FUNCTION
 700         bfd_set_reloc
 701
 702 SYNOPSIS
 703         void bfd_set_reloc
 704           (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
 705
 706 DESCRIPTION
 707         Set the relocation pointer and count within
 708         section @var{sec} to the values @var{rel} and @var{count}.
 709         The argument @var{abfd} is ignored.
 710
 711 */
 712
 713 void
 714 bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED,
 715                sec_ptr asect,
 716                arelent **location,
 717                unsigned int count)
 718 {
 719   asect->orelocation = location;
 720   asect->reloc_count = count;
 721 }
 722
 723 /*
 724 FUNCTION
 725         bfd_set_file_flags
 726
 727 SYNOPSIS
 728         bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
 729
 730 DESCRIPTION
 731         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
 732
 733         Possible errors are:
 734         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
 735         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
 736         o <<bfd_error_invalid_operation>> -
 737         The flag word contained a bit which was not applicable to the
 738         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
 739         on a BFD format which does not support demand paging.
 740
 741 */
 742
 743 bfd_boolean
 744 bfd_set_file_flags (bfd *abfd, flagword flags)
 745 {
 746   if (abfd->format != bfd_object)
 747     {
 748       bfd_set_error (bfd_error_wrong_format);
 749       return FALSE;
 750     }
 751
 752   if (bfd_read_p (abfd))
 753     {
 754       bfd_set_error (bfd_error_invalid_operation);
 755       return FALSE;
 756     }
 757
 758   bfd_get_file_flags (abfd) = flags;
 759   if ((flags & bfd_applicable_file_flags (abfd)) != flags)
 760     {
 761       bfd_set_error (bfd_error_invalid_operation);
 762       return FALSE;
 763     }
 764
 765   return TRUE;
 766 }
 767
 768 void
 769 bfd_assert (const char *file, int line)
 770 {
 771   (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"),
 772                          BFD_VERSION_STRING, file, line);
 773 }
 774
 775 /* A more or less friendly abort message.  In libbfd.h abort is
 776    defined to call this function.  */
 777
 778 #ifndef EXIT_FAILURE
 779 #define EXIT_FAILURE 1
 780 #endif
 781
 782 void
 783 _bfd_abort (const char *file, int line, const char *fn)
 784 {
 785   if (fn != NULL)
 786     (*_bfd_error_handler)
 787       (_("BFD %s internal error, aborting at %s line %d in %s\n"),
 788        BFD_VERSION_STRING, file, line, fn);
 789   else
 790     (*_bfd_error_handler)
 791       (_("BFD %s internal error, aborting at %s line %d\n"),
 792        BFD_VERSION_STRING, file, line);
 793   (*_bfd_error_handler) (_("Please report this bug.\n"));
 794   xexit (EXIT_FAILURE);
 795 }
 796
 797 /*
 798 FUNCTION
 799         bfd_get_arch_size
 800
 801 SYNOPSIS
 802         int bfd_get_arch_size (bfd *abfd);
 803
 804 DESCRIPTION
 805         Returns the architecture address size, in bits, as determined
 806         by the object file's format.  For ELF, this information is
 807         included in the header.
 808
 809 RETURNS
 810         Returns the arch size in bits if known, <<-1>> otherwise.
 811 */
 812
 813 int
 814 bfd_get_arch_size (bfd *abfd)
 815 {
 816   if (abfd->xvec->flavour == bfd_target_elf_flavour)
 817     return get_elf_backend_data (abfd)->s->arch_size;
 818
 819   return -1;
 820 }
 821
 822 /*
 823 FUNCTION
 824         bfd_get_sign_extend_vma
 825
 826 SYNOPSIS
 827         int bfd_get_sign_extend_vma (bfd *abfd);
 828
 829 DESCRIPTION
 830         Indicates if the target architecture "naturally" sign extends
 831         an address.  Some architectures implicitly sign extend address
 832         values when they are converted to types larger than the size
 833         of an address.  For instance, bfd_get_start_address() will
 834         return an address sign extended to fill a bfd_vma when this is
 835         the case.
 836
 837 RETURNS
 838         Returns <<1>> if the target architecture is known to sign
 839         extend addresses, <<0>> if the target architecture is known to
 840         not sign extend addresses, and <<-1>> otherwise.
 841 */
 842
 843 int
 844 bfd_get_sign_extend_vma (bfd *abfd)
 845 {
 846   char *name;
 847
 848   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 849     return get_elf_backend_data (abfd)->sign_extend_vma;
 850
 851   name = bfd_get_target (abfd);
 852
 853   /* Return a proper value for DJGPP & PE COFF (x86 COFF variants).
 854      This function is required for DWARF2 support, but there is
 855      no place to store this information in the COFF back end.
 856      Should enough other COFF targets add support for DWARF2,
 857      a place will have to be found.  Until then, this hack will do.  */
 858   if (strncmp (name, "coff-go32", sizeof ("coff-go32") - 1) == 0
 859       || strcmp (name, "pe-i386") == 0
 860       || strcmp (name, "pei-i386") == 0)
 861     return 1;
 862
 863   bfd_set_error (bfd_error_wrong_format);
 864   return -1;
 865 }
 866
 867 /*
 868 FUNCTION
 869         bfd_set_start_address
 870
 871 SYNOPSIS
 872         bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
 873
 874 DESCRIPTION
 875         Make @var{vma} the entry point of output BFD @var{abfd}.
 876
 877 RETURNS
 878         Returns <<TRUE>> on success, <<FALSE>> otherwise.
 879 */
 880
 881 bfd_boolean
 882 bfd_set_start_address (bfd *abfd, bfd_vma vma)
 883 {
 884   abfd->start_address = vma;
 885   return TRUE;
 886 }
 887
 888 /*
 889 FUNCTION
 890         bfd_get_gp_size
 891
 892 SYNOPSIS
 893         unsigned int bfd_get_gp_size (bfd *abfd);
 894
 895 DESCRIPTION
 896         Return the maximum size of objects to be optimized using the GP
 897         register under MIPS ECOFF.  This is typically set by the <<-G>>
 898         argument to the compiler, assembler or linker.
 899 */
 900
 901 unsigned int
 902 bfd_get_gp_size (bfd *abfd)
 903 {
 904   if (abfd->format == bfd_object)
 905     {
 906       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 907         return ecoff_data (abfd)->gp_size;
 908       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 909         return elf_gp_size (abfd);
 910     }
 911   return 0;
 912 }
 913
 914 /*
 915 FUNCTION
 916         bfd_set_gp_size
 917
 918 SYNOPSIS
 919         void bfd_set_gp_size (bfd *abfd, unsigned int i);
 920
 921 DESCRIPTION
 922         Set the maximum size of objects to be optimized using the GP
 923         register under ECOFF or MIPS ELF.  This is typically set by
 924         the <<-G>> argument to the compiler, assembler or linker.
 925 */
 926
 927 void
 928 bfd_set_gp_size (bfd *abfd, unsigned int i)
 929 {
 930   /* Don't try to set GP size on an archive or core file!  */
 931   if (abfd->format != bfd_object)
 932     return;
 933
 934   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 935     ecoff_data (abfd)->gp_size = i;
 936   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 937     elf_gp_size (abfd) = i;
 938 }
 939
 940 /* Get the GP value.  This is an internal function used by some of the
 941    relocation special_function routines on targets which support a GP
 942    register.  */
 943
 944 bfd_vma
 945 _bfd_get_gp_value (bfd *abfd)
 946 {
 947   if (! abfd)
 948     return 0;
 949   if (abfd->format != bfd_object)
 950     return 0;
 951
 952   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 953     return ecoff_data (abfd)->gp;
 954   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 955     return elf_gp (abfd);
 956
 957   return 0;
 958 }
 959
 960 /* Set the GP value.  */
 961
 962 void
 963 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
 964 {
 965   if (! abfd)
 966     BFD_FAIL ();
 967   if (abfd->format != bfd_object)
 968     return;
 969
 970   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 971     ecoff_data (abfd)->gp = v;
 972   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 973     elf_gp (abfd) = v;
 974 }
 975
 976 /*
 977 FUNCTION
 978         bfd_scan_vma
 979
 980 SYNOPSIS
 981         bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
 982
 983 DESCRIPTION
 984         Convert, like <<strtoul>>, a numerical expression
 985         @var{string} into a <<bfd_vma>> integer, and return that integer.
 986         (Though without as many bells and whistles as <<strtoul>>.)
 987         The expression is assumed to be unsigned (i.e., positive).
 988         If given a @var{base}, it is used as the base for conversion.
 989         A base of 0 causes the function to interpret the string
 990         in hex if a leading "0x" or "0X" is found, otherwise
 991         in octal if a leading zero is found, otherwise in decimal.
 992
 993         If the value would overflow, the maximum <<bfd_vma>> value is
 994         returned.
 995 */
 996
 997 bfd_vma
 998 bfd_scan_vma (const char *string, const char **end, int base)
 999 {
1000   bfd_vma value;
1001   bfd_vma cutoff;
1002   unsigned int cutlim;
1003   int overflow;
1004
1005   /* Let the host do it if possible.  */
1006   if (sizeof (bfd_vma) <= sizeof (unsigned long))
1007     return strtoul (string, (char **) end, base);
1008
1009 #ifdef HAVE_STRTOULL
1010   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1011     return strtoull (string, (char **) end, base);
1012 #endif
1013
1014   if (base == 0)
1015     {
1016       if (string[0] == '0')
1017         {
1018           if ((string[1] == 'x') || (string[1] == 'X'))
1019             base = 16;
1020           else
1021             base = 8;
1022         }
1023     }
1024
1025   if ((base < 2) || (base > 36))
1026     base = 10;
1027
1028   if (base == 16
1029       && string[0] == '0'
1030       && (string[1] == 'x' || string[1] == 'X')
1031       && ISXDIGIT (string[2]))
1032     {
1033       string += 2;
1034     }
1035
1036   cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1037   cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1038   value = 0;
1039   overflow = 0;
1040   while (1)
1041     {
1042       unsigned int digit;
1043
1044       digit = *string;
1045       if (ISDIGIT (digit))
1046         digit = digit - '0';
1047       else if (ISALPHA (digit))
1048         digit = TOUPPER (digit) - 'A' + 10;
1049       else
1050         break;
1051       if (digit >= (unsigned int) base)
1052         break;
1053       if (value > cutoff || (value == cutoff && digit > cutlim))
1054         overflow = 1;
1055       value = value * base + digit;
1056       ++string;
1057     }
1058
1059   if (overflow)
1060     value = ~ (bfd_vma) 0;
1061
1062   if (end != NULL)
1063     *end = string;
1064
1065   return value;
1066 }
1067
1068 /*
1069 FUNCTION
1070         bfd_copy_private_header_data
1071
1072 SYNOPSIS
1073         bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1074
1075 DESCRIPTION
1076         Copy private BFD header information from the BFD @var{ibfd} to the
1077         the BFD @var{obfd}.  This copies information that may require
1078         sections to exist, but does not require symbol tables.  Return
1079         <<true>> on success, <<false>> on error.
1080         Possible error returns are:
1081
1082         o <<bfd_error_no_memory>> -
1083         Not enough memory exists to create private data for @var{obfd}.
1084
1085 .#define bfd_copy_private_header_data(ibfd, obfd) \
1086 .     BFD_SEND (obfd, _bfd_copy_private_header_data, \
1087 .               (ibfd, obfd))
1088
1089 */
1090
1091 /*
1092 FUNCTION
1093         bfd_copy_private_bfd_data
1094
1095 SYNOPSIS
1096         bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1097
1098 DESCRIPTION
1099         Copy private BFD information from the BFD @var{ibfd} to the
1100         the BFD @var{obfd}.  Return <<TRUE>> on success, <<FALSE>> on error.
1101         Possible error returns are:
1102
1103         o <<bfd_error_no_memory>> -
1104         Not enough memory exists to create private data for @var{obfd}.
1105
1106 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1107 .     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1108 .               (ibfd, obfd))
1109
1110 */
1111
1112 /*
1113 FUNCTION
1114         bfd_merge_private_bfd_data
1115
1116 SYNOPSIS
1117         bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
1118
1119 DESCRIPTION
1120         Merge private BFD information from the BFD @var{ibfd} to the
1121         the output file BFD @var{obfd} when linking.  Return <<TRUE>>
1122         on success, <<FALSE>> on error.  Possible error returns are:
1123
1124         o <<bfd_error_no_memory>> -
1125         Not enough memory exists to create private data for @var{obfd}.
1126
1127 .#define bfd_merge_private_bfd_data(ibfd, obfd) \
1128 .     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1129 .               (ibfd, obfd))
1130
1131 */
1132
1133 /*
1134 FUNCTION
1135         bfd_set_private_flags
1136
1137 SYNOPSIS
1138         bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1139
1140 DESCRIPTION
1141         Set private BFD flag information in the BFD @var{abfd}.
1142         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
1143         returns are:
1144
1145         o <<bfd_error_no_memory>> -
1146         Not enough memory exists to create private data for @var{obfd}.
1147
1148 .#define bfd_set_private_flags(abfd, flags) \
1149 .     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1150
1151 */
1152
1153 /*
1154 FUNCTION
1155         Other functions
1156
1157 DESCRIPTION
1158         The following functions exist but have not yet been documented.
1159
1160 .#define bfd_sizeof_headers(abfd, reloc) \
1161 .       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
1162 .
1163 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1164 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
1165 .                 (abfd, sec, syms, off, file, func, line))
1166 .
1167 .#define bfd_find_line(abfd, syms, sym, file, line) \
1168 .       BFD_SEND (abfd, _bfd_find_line, \
1169 .                 (abfd, syms, sym, file, line))
1170 .
1171 .#define bfd_find_inliner_info(abfd, file, func, line) \
1172 .       BFD_SEND (abfd, _bfd_find_inliner_info, \
1173 .                 (abfd, file, func, line))
1174 .
1175 .#define bfd_debug_info_start(abfd) \
1176 .       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1177 .
1178 .#define bfd_debug_info_end(abfd) \
1179 .       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1180 .
1181 .#define bfd_debug_info_accumulate(abfd, section) \
1182 .       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1183 .
1184 .#define bfd_stat_arch_elt(abfd, stat) \
1185 .       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1186 .
1187 .#define bfd_update_armap_timestamp(abfd) \
1188 .       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1189 .
1190 .#define bfd_set_arch_mach(abfd, arch, mach)\
1191 .       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1192 .
1193 .#define bfd_relax_section(abfd, section, link_info, again) \
1194 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1195 .
1196 .#define bfd_gc_sections(abfd, link_info) \
1197 .       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1198 .
1199 .#define bfd_merge_sections(abfd, link_info) \
1200 .       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1201 .
1202 .#define bfd_is_group_section(abfd, sec) \
1203 .       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1204 .
1205 .#define bfd_discard_group(abfd, sec) \
1206 .       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1207 .
1208 .#define bfd_link_hash_table_create(abfd) \
1209 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1210 .
1211 .#define bfd_link_hash_table_free(abfd, hash) \
1212 .       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
1213 .
1214 .#define bfd_link_add_symbols(abfd, info) \
1215 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1216 .
1217 .#define bfd_link_just_syms(abfd, sec, info) \
1218 .       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1219 .
1220 .#define bfd_final_link(abfd, info) \
1221 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1222 .
1223 .#define bfd_free_cached_info(abfd) \
1224 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1225 .
1226 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1227 .       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1228 .
1229 .#define bfd_print_private_bfd_data(abfd, file)\
1230 .       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1231 .
1232 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1233 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1234 .
1235 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1236 .       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1237 .                                                   dyncount, dynsyms, ret))
1238 .
1239 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1240 .       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1241 .
1242 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1243 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1244 .
1245 .extern bfd_byte *bfd_get_relocated_section_contents
1246 .  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1247 .   bfd_boolean, asymbol **);
1248 .
1249
1250 */
1251
1252 bfd_byte *
1253 bfd_get_relocated_section_contents (bfd *abfd,
1254                                     struct bfd_link_info *link_info,
1255                                     struct bfd_link_order *link_order,
1256                                     bfd_byte *data,
1257                                     bfd_boolean relocatable,
1258                                     asymbol **symbols)
1259 {
1260   bfd *abfd2;
1261   bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1262                    bfd_byte *, bfd_boolean, asymbol **);
1263
1264   if (link_order->type == bfd_indirect_link_order)
1265     {
1266       abfd2 = link_order->u.indirect.section->owner;
1267       if (abfd2 == NULL)
1268         abfd2 = abfd;
1269     }
1270   else
1271     abfd2 = abfd;
1272
1273   fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1274
1275   return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1276 }
1277
1278 /* Record information about an ELF program header.  */
1279
1280 bfd_boolean
1281 bfd_record_phdr (bfd *abfd,
1282                  unsigned long type,
1283                  bfd_boolean flags_valid,
1284                  flagword flags,
1285                  bfd_boolean at_valid,
1286                  bfd_vma at,
1287                  bfd_boolean includes_filehdr,
1288                  bfd_boolean includes_phdrs,
1289                  unsigned int count,
1290                  asection **secs)
1291 {
1292   struct elf_segment_map *m, **pm;
1293   bfd_size_type amt;
1294
1295   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1296     return TRUE;
1297
1298   amt = sizeof (struct elf_segment_map);
1299   amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1300   m = bfd_alloc (abfd, amt);
1301   if (m == NULL)
1302     return FALSE;
1303
1304   m->next = NULL;
1305   m->p_type = type;
1306   m->p_flags = flags;
1307   m->p_paddr = at;
1308   m->p_flags_valid = flags_valid;
1309   m->p_paddr_valid = at_valid;
1310   m->includes_filehdr = includes_filehdr;
1311   m->includes_phdrs = includes_phdrs;
1312   m->count = count;
1313   if (count > 0)
1314     memcpy (m->sections, secs, count * sizeof (asection *));
1315
1316   for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
1317     ;
1318   *pm = m;
1319
1320   return TRUE;
1321 }
1322
1323 void
1324 bfd_sprintf_vma (bfd *abfd, char *buf, bfd_vma value)
1325 {
1326   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1327     get_elf_backend_data (abfd)->elf_backend_sprintf_vma (abfd, buf, value);
1328   else
1329     sprintf_vma (buf, value);
1330 }
1331
1332 void
1333 bfd_fprintf_vma (bfd *abfd, void *stream, bfd_vma value)
1334 {
1335   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1336     get_elf_backend_data (abfd)->elf_backend_fprintf_vma (abfd, stream, value);
1337   else
1338     fprintf_vma ((FILE *) stream, value);
1339 }
1340
1341 /*
1342 FUNCTION
1343         bfd_alt_mach_code
1344
1345 SYNOPSIS
1346         bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
1347
1348 DESCRIPTION
1349
1350         When more than one machine code number is available for the
1351         same machine type, this function can be used to switch between
1352         the preferred one (alternative == 0) and any others.  Currently,
1353         only ELF supports this feature, with up to two alternate
1354         machine codes.
1355 */
1356
1357 bfd_boolean
1358 bfd_alt_mach_code (bfd *abfd, int alternative)
1359 {
1360   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1361     {
1362       int code;
1363
1364       switch (alternative)
1365         {
1366         case 0:
1367           code = get_elf_backend_data (abfd)->elf_machine_code;
1368           break;
1369
1370         case 1:
1371           code = get_elf_backend_data (abfd)->elf_machine_alt1;
1372           if (code == 0)
1373             return FALSE;
1374           break;
1375
1376         case 2:
1377           code = get_elf_backend_data (abfd)->elf_machine_alt2;
1378           if (code == 0)
1379             return FALSE;
1380           break;
1381
1382         default:
1383           return FALSE;
1384         }
1385
1386       elf_elfheader (abfd)->e_machine = code;
1387
1388       return TRUE;
1389     }
1390
1391   return FALSE;
1392 }
1393
1394 /*
1395 CODE_FRAGMENT
1396
1397 .struct bfd_preserve
1398 .{
1399 .  void *marker;
1400 .  void *tdata;
1401 .  flagword flags;
1402 .  const struct bfd_arch_info *arch_info;
1403 .  struct bfd_section *sections;
1404 .  struct bfd_section *section_last;
1405 .  unsigned int section_count;
1406 .  struct bfd_hash_table section_htab;
1407 .};
1408 .
1409 */
1410
1411 /*
1412 FUNCTION
1413         bfd_preserve_save
1414
1415 SYNOPSIS
1416         bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);
1417
1418 DESCRIPTION
1419         When testing an object for compatibility with a particular
1420         target back-end, the back-end object_p function needs to set
1421         up certain fields in the bfd on successfully recognizing the
1422         object.  This typically happens in a piecemeal fashion, with
1423         failures possible at many points.  On failure, the bfd is
1424         supposed to be restored to its initial state, which is
1425         virtually impossible.  However, restoring a subset of the bfd
1426         state works in practice.  This function stores the subset and
1427         reinitializes the bfd.
1428
1429 */
1430
1431 bfd_boolean
1432 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
1433 {
1434   preserve->tdata = abfd->tdata.any;
1435   preserve->arch_info = abfd->arch_info;
1436   preserve->flags = abfd->flags;
1437   preserve->sections = abfd->sections;
1438   preserve->section_last = abfd->section_last;
1439   preserve->section_count = abfd->section_count;
1440   preserve->section_htab = abfd->section_htab;
1441
1442   if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc))
1443     return FALSE;
1444
1445   abfd->tdata.any = NULL;
1446   abfd->arch_info = &bfd_default_arch_struct;
1447   abfd->flags &= BFD_IN_MEMORY;
1448   abfd->sections = NULL;
1449   abfd->section_last = NULL;
1450   abfd->section_count = 0;
1451
1452   return TRUE;
1453 }
1454
1455 /*
1456 FUNCTION
1457         bfd_preserve_restore
1458
1459 SYNOPSIS
1460         void bfd_preserve_restore (bfd *, struct bfd_preserve *);
1461
1462 DESCRIPTION
1463         This function restores bfd state saved by bfd_preserve_save.
1464         If MARKER is non-NULL in struct bfd_preserve then that block
1465         and all subsequently bfd_alloc'd memory is freed.
1466
1467 */
1468
1469 void
1470 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
1471 {
1472   bfd_hash_table_free (&abfd->section_htab);
1473
1474   abfd->tdata.any = preserve->tdata;
1475   abfd->arch_info = preserve->arch_info;
1476   abfd->flags = preserve->flags;
1477   abfd->section_htab = preserve->section_htab;
1478   abfd->sections = preserve->sections;
1479   abfd->section_last = preserve->section_last;
1480   abfd->section_count = preserve->section_count;
1481
1482   /* bfd_release frees all memory more recently bfd_alloc'd than
1483      its arg, as well as its arg.  */
1484   if (preserve->marker != NULL)
1485     {
1486       bfd_release (abfd, preserve->marker);
1487       preserve->marker = NULL;
1488     }
1489 }
1490
1491 /*
1492 FUNCTION
1493         bfd_preserve_finish
1494
1495 SYNOPSIS
1496         void bfd_preserve_finish (bfd *, struct bfd_preserve *);
1497
1498 DESCRIPTION
1499         This function should be called when the bfd state saved by
1500         bfd_preserve_save is no longer needed.  ie. when the back-end
1501         object_p function returns with success.
1502
1503 */
1504
1505 void
1506 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
1507 {
1508   /* It would be nice to be able to free more memory here, eg. old
1509      tdata, but that's not possible since these blocks are sitting
1510      inside bfd_alloc'd memory.  The section hash is on a separate
1511      objalloc.  */
1512   bfd_hash_table_free (&preserve->section_htab);
1513 }
1514
1515 /*
1516 FUNCTION
1517         bfd_hide_symbol
1518
1519 SYNOPSIS
1520         void bfd_hide_symbol (bfd *,
1521                               struct bfd_link_info *,
1522                               struct bfd_link_hash_entry *,
1523                               bfd_boolean);
1524
1525 DESCRIPTION
1526         This function hides a symbol so that it won't be exported.
1527
1528 */
1529
1530 void
1531 bfd_hide_symbol (bfd *abfd,
1532                  struct bfd_link_info *link_info,
1533                  struct bfd_link_hash_entry *h,
1534                  bfd_boolean force_local)
1535 {
1536   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1537     (get_elf_backend_data (abfd)->elf_backend_hide_symbol)
1538       (link_info, (struct elf_link_hash_entry *) h, force_local);
1539 }