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