bfd/bfd.c

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