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 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-arm-wince-little") == 0
 920       || strcmp (name, "pei-arm-wince-little") == 0)
 921     return 1;
 922
 923   bfd_set_error (bfd_error_wrong_format);
 924   return -1;
 925 }
 926
 927 /*
 928 FUNCTION
 929         bfd_set_start_address
 930
 931 SYNOPSIS
 932         bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
 933
 934 DESCRIPTION
 935         Make @var{vma} the entry point of output BFD @var{abfd}.
 936
 937 RETURNS
 938         Returns <<TRUE>> on success, <<FALSE>> otherwise.
 939 */
 940
 941 bfd_boolean
 942 bfd_set_start_address (bfd *abfd, bfd_vma vma)
 943 {
 944   abfd->start_address = vma;
 945   return TRUE;
 946 }
 947
 948 /*
 949 FUNCTION
 950         bfd_get_gp_size
 951
 952 SYNOPSIS
 953         unsigned int bfd_get_gp_size (bfd *abfd);
 954
 955 DESCRIPTION
 956         Return the maximum size of objects to be optimized using the GP
 957         register under MIPS ECOFF.  This is typically set by the <<-G>>
 958         argument to the compiler, assembler or linker.
 959 */
 960
 961 unsigned int
 962 bfd_get_gp_size (bfd *abfd)
 963 {
 964   if (abfd->format == bfd_object)
 965     {
 966       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 967         return ecoff_data (abfd)->gp_size;
 968       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 969         return elf_gp_size (abfd);
 970     }
 971   return 0;
 972 }
 973
 974 /*
 975 FUNCTION
 976         bfd_set_gp_size
 977
 978 SYNOPSIS
 979         void bfd_set_gp_size (bfd *abfd, unsigned int i);
 980
 981 DESCRIPTION
 982         Set the maximum size of objects to be optimized using the GP
 983         register under ECOFF or MIPS ELF.  This is typically set by
 984         the <<-G>> argument to the compiler, assembler or linker.
 985 */
 986
 987 void
 988 bfd_set_gp_size (bfd *abfd, unsigned int i)
 989 {
 990   /* Don't try to set GP size on an archive or core file!  */
 991   if (abfd->format != bfd_object)
 992     return;
 993
 994   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 995     ecoff_data (abfd)->gp_size = i;
 996   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 997     elf_gp_size (abfd) = i;
 998 }
 999
1000 /* Get the GP value.  This is an internal function used by some of the
1001    relocation special_function routines on targets which support a GP
1002    register.  */
1003
1004 bfd_vma
1005 _bfd_get_gp_value (bfd *abfd)
1006 {
1007   if (! abfd)
1008     return 0;
1009   if (abfd->format != bfd_object)
1010     return 0;
1011
1012   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1013     return ecoff_data (abfd)->gp;
1014   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1015     return elf_gp (abfd);
1016
1017   return 0;
1018 }
1019
1020 /* Set the GP value.  */
1021
1022 void
1023 _bfd_set_gp_value (bfd *abfd, bfd_vma v)
1024 {
1025   if (! abfd)
1026     abort ();
1027   if (abfd->format != bfd_object)
1028     return;
1029
1030   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1031     ecoff_data (abfd)->gp = v;
1032   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1033     elf_gp (abfd) = v;
1034 }
1035
1036 /*
1037 FUNCTION
1038         bfd_scan_vma
1039
1040 SYNOPSIS
1041         bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
1042
1043 DESCRIPTION
1044         Convert, like <<strtoul>>, a numerical expression
1045         @var{string} into a <<bfd_vma>> integer, and return that integer.
1046         (Though without as many bells and whistles as <<strtoul>>.)
1047         The expression is assumed to be unsigned (i.e., positive).
1048         If given a @var{base}, it is used as the base for conversion.
1049         A base of 0 causes the function to interpret the string
1050         in hex if a leading "0x" or "0X" is found, otherwise
1051         in octal if a leading zero is found, otherwise in decimal.
1052
1053         If the value would overflow, the maximum <<bfd_vma>> value is
1054         returned.
1055 */
1056
1057 bfd_vma
1058 bfd_scan_vma (const char *string, const char **end, int base)
1059 {
1060   bfd_vma value;
1061   bfd_vma cutoff;
1062   unsigned int cutlim;
1063   int overflow;
1064
1065   /* Let the host do it if possible.  */
1066   if (sizeof (bfd_vma) <= sizeof (unsigned long))
1067     return strtoul (string, (char **) end, base);
1068
1069 #ifdef HAVE_STRTOULL
1070   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1071     return strtoull (string, (char **) end, base);
1072 #endif
1073
1074   if (base == 0)
1075     {
1076       if (string[0] == '0')
1077         {
1078           if ((string[1] == 'x') || (string[1] == 'X'))
1079             base = 16;
1080           else
1081             base = 8;
1082         }
1083     }
1084
1085   if ((base < 2) || (base > 36))
1086     base = 10;
1087
1088   if (base == 16
1089       && string[0] == '0'
1090       && (string[1] == 'x' || string[1] == 'X')
1091       && ISXDIGIT (string[2]))
1092     {
1093       string += 2;
1094     }
1095
1096   cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1097   cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1098   value = 0;
1099   overflow = 0;
1100   while (1)
1101     {
1102       unsigned int digit;
1103
1104       digit = *string;
1105       if (ISDIGIT (digit))
1106         digit = digit - '0';
1107       else if (ISALPHA (digit))
1108         digit = TOUPPER (digit) - 'A' + 10;
1109       else
1110         break;
1111       if (digit >= (unsigned int) base)
1112         break;
1113       if (value > cutoff || (value == cutoff && digit > cutlim))
1114         overflow = 1;
1115       value = value * base + digit;
1116       ++string;
1117     }
1118
1119   if (overflow)
1120     value = ~ (bfd_vma) 0;
1121
1122   if (end != NULL)
1123     *end = string;
1124
1125   return value;
1126 }
1127
1128 /*
1129 FUNCTION
1130         bfd_copy_private_header_data
1131
1132 SYNOPSIS
1133         bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1134
1135 DESCRIPTION
1136         Copy private BFD header information from the BFD @var{ibfd} to the
1137         the BFD @var{obfd}.  This copies information that may require
1138         sections to exist, but does not require symbol tables.  Return
1139         <<true>> on success, <<false>> on error.
1140         Possible error returns are:
1141
1142         o <<bfd_error_no_memory>> -
1143         Not enough memory exists to create private data for @var{obfd}.
1144
1145 .#define bfd_copy_private_header_data(ibfd, obfd) \
1146 .     BFD_SEND (obfd, _bfd_copy_private_header_data, \
1147 .               (ibfd, obfd))
1148
1149 */
1150
1151 /*
1152 FUNCTION
1153         bfd_copy_private_bfd_data
1154
1155 SYNOPSIS
1156         bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1157
1158 DESCRIPTION
1159         Copy private BFD information from the BFD @var{ibfd} to the
1160         the BFD @var{obfd}.  Return <<TRUE>> on success, <<FALSE>> on error.
1161         Possible error returns are:
1162
1163         o <<bfd_error_no_memory>> -
1164         Not enough memory exists to create private data for @var{obfd}.
1165
1166 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1167 .     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1168 .               (ibfd, obfd))
1169
1170 */
1171
1172 /*
1173 FUNCTION
1174         bfd_merge_private_bfd_data
1175
1176 SYNOPSIS
1177         bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
1178
1179 DESCRIPTION
1180         Merge private BFD information from the BFD @var{ibfd} to the
1181         the output file BFD @var{obfd} when linking.  Return <<TRUE>>
1182         on success, <<FALSE>> on error.  Possible error returns are:
1183
1184         o <<bfd_error_no_memory>> -
1185         Not enough memory exists to create private data for @var{obfd}.
1186
1187 .#define bfd_merge_private_bfd_data(ibfd, obfd) \
1188 .     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1189 .               (ibfd, obfd))
1190
1191 */
1192
1193 /*
1194 FUNCTION
1195         bfd_set_private_flags
1196
1197 SYNOPSIS
1198         bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1199
1200 DESCRIPTION
1201         Set private BFD flag information in the BFD @var{abfd}.
1202         Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
1203         returns are:
1204
1205         o <<bfd_error_no_memory>> -
1206         Not enough memory exists to create private data for @var{obfd}.
1207
1208 .#define bfd_set_private_flags(abfd, flags) \
1209 .     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1210
1211 */
1212
1213 /*
1214 FUNCTION
1215         Other functions
1216
1217 DESCRIPTION
1218         The following functions exist but have not yet been documented.
1219
1220 .#define bfd_sizeof_headers(abfd, info) \
1221 .       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
1222 .
1223 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1224 .       BFD_SEND (abfd, _bfd_find_nearest_line, \
1225 .                 (abfd, sec, syms, off, file, func, line))
1226 .
1227 .#define bfd_find_line(abfd, syms, sym, file, line) \
1228 .       BFD_SEND (abfd, _bfd_find_line, \
1229 .                 (abfd, syms, sym, file, line))
1230 .
1231 .#define bfd_find_inliner_info(abfd, file, func, line) \
1232 .       BFD_SEND (abfd, _bfd_find_inliner_info, \
1233 .                 (abfd, file, func, line))
1234 .
1235 .#define bfd_debug_info_start(abfd) \
1236 .       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1237 .
1238 .#define bfd_debug_info_end(abfd) \
1239 .       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1240 .
1241 .#define bfd_debug_info_accumulate(abfd, section) \
1242 .       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1243 .
1244 .#define bfd_stat_arch_elt(abfd, stat) \
1245 .       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1246 .
1247 .#define bfd_update_armap_timestamp(abfd) \
1248 .       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1249 .
1250 .#define bfd_set_arch_mach(abfd, arch, mach)\
1251 .       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1252 .
1253 .#define bfd_relax_section(abfd, section, link_info, again) \
1254 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1255 .
1256 .#define bfd_gc_sections(abfd, link_info) \
1257 .       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1258 .
1259 .#define bfd_merge_sections(abfd, link_info) \
1260 .       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1261 .
1262 .#define bfd_is_group_section(abfd, sec) \
1263 .       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1264 .
1265 .#define bfd_discard_group(abfd, sec) \
1266 .       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1267 .
1268 .#define bfd_link_hash_table_create(abfd) \
1269 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1270 .
1271 .#define bfd_link_hash_table_free(abfd, hash) \
1272 .       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
1273 .
1274 .#define bfd_link_add_symbols(abfd, info) \
1275 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1276 .
1277 .#define bfd_link_just_syms(abfd, sec, info) \
1278 .       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1279 .
1280 .#define bfd_final_link(abfd, info) \
1281 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1282 .
1283 .#define bfd_free_cached_info(abfd) \
1284 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1285 .
1286 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1287 .       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1288 .
1289 .#define bfd_print_private_bfd_data(abfd, file)\
1290 .       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1291 .
1292 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1293 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1294 .
1295 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1296 .       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1297 .                                                   dyncount, dynsyms, ret))
1298 .
1299 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1300 .       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1301 .
1302 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1303 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1304 .
1305 .extern bfd_byte *bfd_get_relocated_section_contents
1306 .  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1307 .   bfd_boolean, asymbol **);
1308 .
1309
1310 */
1311
1312 bfd_byte *
1313 bfd_get_relocated_section_contents (bfd *abfd,
1314                                     struct bfd_link_info *link_info,
1315                                     struct bfd_link_order *link_order,
1316                                     bfd_byte *data,
1317                                     bfd_boolean relocatable,
1318                                     asymbol **symbols)
1319 {
1320   bfd *abfd2;
1321   bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1322                    bfd_byte *, bfd_boolean, asymbol **);
1323
1324   if (link_order->type == bfd_indirect_link_order)
1325     {
1326       abfd2 = link_order->u.indirect.section->owner;
1327       if (abfd2 == NULL)
1328         abfd2 = abfd;
1329     }
1330   else
1331     abfd2 = abfd;
1332
1333   fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1334
1335   return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1336 }
1337
1338 /* Record information about an ELF program header.  */
1339
1340 bfd_boolean
1341 bfd_record_phdr (bfd *abfd,
1342                  unsigned long type,
1343                  bfd_boolean flags_valid,
1344                  flagword flags,
1345                  bfd_boolean at_valid,
1346                  bfd_vma at,
1347                  bfd_boolean includes_filehdr,
1348                  bfd_boolean includes_phdrs,
1349                  unsigned int count,
1350                  asection **secs)
1351 {
1352   struct elf_segment_map *m, **pm;
1353   bfd_size_type amt;
1354
1355   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1356     return TRUE;
1357
1358   amt = sizeof (struct elf_segment_map);
1359   amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1360   m = bfd_zalloc (abfd, amt);
1361   if (m == NULL)
1362     return FALSE;
1363
1364   m->p_type = type;
1365   m->p_flags = flags;
1366   m->p_paddr = at;
1367   m->p_flags_valid = flags_valid;
1368   m->p_paddr_valid = at_valid;
1369   m->includes_filehdr = includes_filehdr;
1370   m->includes_phdrs = includes_phdrs;
1371   m->count = count;
1372   if (count > 0)
1373     memcpy (m->sections, secs, count * sizeof (asection *));
1374
1375   for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
1376     ;
1377   *pm = m;
1378
1379   return TRUE;
1380 }
1381
1382 #ifdef BFD64
1383 /* Return true iff this target is 32-bit.  */
1384
1385 static bfd_boolean
1386 is32bit (bfd *abfd)
1387 {
1388   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1389     {
1390       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1391       return bed->s->elfclass == ELFCLASS32;
1392     }
1393
1394   /* For non-ELF, make a guess based on the target name.  */
1395   return (strstr (bfd_get_target (abfd), "64") == NULL
1396           && strcmp (bfd_get_target (abfd), "mmo") != 0);
1397 }
1398 #endif
1399
1400 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
1401    target's address size.  */
1402
1403 void
1404 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
1405 {
1406 #ifdef BFD64
1407   if (is32bit (abfd))
1408     {
1409       sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
1410       return;
1411     }
1412 #endif
1413   sprintf_vma (buf, value);
1414 }
1415
1416 void
1417 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
1418 {
1419 #ifdef BFD64
1420   if (is32bit (abfd))
1421     {
1422       fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
1423       return;
1424     }
1425 #endif
1426   fprintf_vma ((FILE *) stream, value);
1427 }
1428
1429 /*
1430 FUNCTION
1431         bfd_alt_mach_code
1432
1433 SYNOPSIS
1434         bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
1435
1436 DESCRIPTION
1437
1438         When more than one machine code number is available for the
1439         same machine type, this function can be used to switch between
1440         the preferred one (alternative == 0) and any others.  Currently,
1441         only ELF supports this feature, with up to two alternate
1442         machine codes.
1443 */
1444
1445 bfd_boolean
1446 bfd_alt_mach_code (bfd *abfd, int alternative)
1447 {
1448   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1449     {
1450       int code;
1451
1452       switch (alternative)
1453         {
1454         case 0:
1455           code = get_elf_backend_data (abfd)->elf_machine_code;
1456           break;
1457
1458         case 1:
1459           code = get_elf_backend_data (abfd)->elf_machine_alt1;
1460           if (code == 0)
1461             return FALSE;
1462           break;
1463
1464         case 2:
1465           code = get_elf_backend_data (abfd)->elf_machine_alt2;
1466           if (code == 0)
1467             return FALSE;
1468           break;
1469
1470         default:
1471           return FALSE;
1472         }
1473
1474       elf_elfheader (abfd)->e_machine = code;
1475
1476       return TRUE;
1477     }
1478
1479   return FALSE;
1480 }
1481
1482 /*
1483 CODE_FRAGMENT
1484
1485 .struct bfd_preserve
1486 .{
1487 .  void *marker;
1488 .  void *tdata;
1489 .  flagword flags;
1490 .  const struct bfd_arch_info *arch_info;
1491 .  struct bfd_section *sections;
1492 .  struct bfd_section *section_last;
1493 .  unsigned int section_count;
1494 .  struct bfd_hash_table section_htab;
1495 .};
1496 .
1497 */
1498
1499 /*
1500 FUNCTION
1501         bfd_preserve_save
1502
1503 SYNOPSIS
1504         bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);
1505
1506 DESCRIPTION
1507         When testing an object for compatibility with a particular
1508         target back-end, the back-end object_p function needs to set
1509         up certain fields in the bfd on successfully recognizing the
1510         object.  This typically happens in a piecemeal fashion, with
1511         failures possible at many points.  On failure, the bfd is
1512         supposed to be restored to its initial state, which is
1513         virtually impossible.  However, restoring a subset of the bfd
1514         state works in practice.  This function stores the subset and
1515         reinitializes the bfd.
1516
1517 */
1518
1519 bfd_boolean
1520 bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
1521 {
1522   preserve->tdata = abfd->tdata.any;
1523   preserve->arch_info = abfd->arch_info;
1524   preserve->flags = abfd->flags;
1525   preserve->sections = abfd->sections;
1526   preserve->section_last = abfd->section_last;
1527   preserve->section_count = abfd->section_count;
1528   preserve->section_htab = abfd->section_htab;
1529
1530   if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
1531                              sizeof (struct section_hash_entry)))
1532     return FALSE;
1533
1534   abfd->tdata.any = NULL;
1535   abfd->arch_info = &bfd_default_arch_struct;
1536   abfd->flags &= BFD_IN_MEMORY;
1537   abfd->sections = NULL;
1538   abfd->section_last = NULL;
1539   abfd->section_count = 0;
1540
1541   return TRUE;
1542 }
1543
1544 /*
1545 FUNCTION
1546         bfd_preserve_restore
1547
1548 SYNOPSIS
1549         void bfd_preserve_restore (bfd *, struct bfd_preserve *);
1550
1551 DESCRIPTION
1552         This function restores bfd state saved by bfd_preserve_save.
1553         If MARKER is non-NULL in struct bfd_preserve then that block
1554         and all subsequently bfd_alloc'd memory is freed.
1555
1556 */
1557
1558 void
1559 bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
1560 {
1561   bfd_hash_table_free (&abfd->section_htab);
1562
1563   abfd->tdata.any = preserve->tdata;
1564   abfd->arch_info = preserve->arch_info;
1565   abfd->flags = preserve->flags;
1566   abfd->section_htab = preserve->section_htab;
1567   abfd->sections = preserve->sections;
1568   abfd->section_last = preserve->section_last;
1569   abfd->section_count = preserve->section_count;
1570
1571   /* bfd_release frees all memory more recently bfd_alloc'd than
1572      its arg, as well as its arg.  */
1573   if (preserve->marker != NULL)
1574     {
1575       bfd_release (abfd, preserve->marker);
1576       preserve->marker = NULL;
1577     }
1578 }
1579
1580 /*
1581 FUNCTION
1582         bfd_preserve_finish
1583
1584 SYNOPSIS
1585         void bfd_preserve_finish (bfd *, struct bfd_preserve *);
1586
1587 DESCRIPTION
1588         This function should be called when the bfd state saved by
1589         bfd_preserve_save is no longer needed.  ie. when the back-end
1590         object_p function returns with success.
1591
1592 */
1593
1594 void
1595 bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
1596 {
1597   /* It would be nice to be able to free more memory here, eg. old
1598      tdata, but that's not possible since these blocks are sitting
1599      inside bfd_alloc'd memory.  The section hash is on a separate
1600      objalloc.  */
1601   bfd_hash_table_free (&preserve->section_htab);
1602 }
1603
1604 /*
1605 FUNCTION
1606         bfd_emul_get_maxpagesize
1607
1608 SYNOPSIS
1609         bfd_vma bfd_emul_get_maxpagesize (const char *);
1610
1611 DESCRIPTION
1612         Returns the maximum page size, in bytes, as determined by
1613         emulation.
1614
1615 RETURNS
1616         Returns the maximum page size in bytes for ELF, abort
1617         otherwise.
1618 */
1619
1620 bfd_vma
1621 bfd_emul_get_maxpagesize (const char *emul)
1622 {
1623   const bfd_target *target;
1624
1625   target = bfd_find_target (emul, NULL);
1626   if (target != NULL
1627       && target->flavour == bfd_target_elf_flavour)
1628     return xvec_get_elf_backend_data (target)->maxpagesize;
1629
1630   abort ();
1631   return 0;
1632 }
1633
1634 static void
1635 bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size,
1636                       int offset, const bfd_target *orig_target)
1637 {
1638   if (target->flavour == bfd_target_elf_flavour)
1639     {
1640       const struct elf_backend_data *bed;
1641
1642       bed = xvec_get_elf_backend_data (target);
1643       *((bfd_vma *) ((char *) bed + offset)) = size;
1644     }
1645
1646   if (target->alternative_target
1647       && target->alternative_target != orig_target)
1648     bfd_elf_set_pagesize (target->alternative_target, size, offset,
1649                           orig_target);
1650 }
1651
1652 /*
1653 FUNCTION
1654         bfd_emul_set_maxpagesize
1655
1656 SYNOPSIS
1657         void bfd_emul_set_maxpagesize (const char *, bfd_vma);
1658
1659 DESCRIPTION
1660         For ELF, set the maximum page size for the emulation.  It is
1661         a no-op for other formats.
1662
1663 */
1664
1665 void
1666 bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
1667 {
1668   const bfd_target *target;
1669
1670   target = bfd_find_target (emul, NULL);
1671   if (target)
1672     bfd_elf_set_pagesize (target, size,
1673                           offsetof (struct elf_backend_data,
1674                                     maxpagesize), target);
1675 }
1676
1677 /*
1678 FUNCTION
1679         bfd_emul_get_commonpagesize
1680
1681 SYNOPSIS
1682         bfd_vma bfd_emul_get_commonpagesize (const char *);
1683
1684 DESCRIPTION
1685         Returns the common page size, in bytes, as determined by
1686         emulation.
1687
1688 RETURNS
1689         Returns the common page size in bytes for ELF, abort otherwise.
1690 */
1691
1692 bfd_vma
1693 bfd_emul_get_commonpagesize (const char *emul)
1694 {
1695   const bfd_target *target;
1696
1697   target = bfd_find_target (emul, NULL);
1698   if (target != NULL
1699       && target->flavour == bfd_target_elf_flavour)
1700     return xvec_get_elf_backend_data (target)->commonpagesize;
1701
1702   abort ();
1703   return 0;
1704 }
1705
1706 /*
1707 FUNCTION
1708         bfd_emul_set_commonpagesize
1709
1710 SYNOPSIS
1711         void bfd_emul_set_commonpagesize (const char *, bfd_vma);
1712
1713 DESCRIPTION
1714         For ELF, set the common page size for the emulation.  It is
1715         a no-op for other formats.
1716
1717 */
1718
1719 void
1720 bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)
1721 {
1722   const bfd_target *target;
1723
1724   target = bfd_find_target (emul, NULL);
1725   if (target)
1726     bfd_elf_set_pagesize (target, size,
1727                           offsetof (struct elf_backend_data,
1728                                     commonpagesize), target);
1729 }
1730
1731 /*
1732 FUNCTION
1733         bfd_demangle
1734
1735 SYNOPSIS
1736         char *bfd_demangle (bfd *, const char *, int);
1737
1738 DESCRIPTION
1739         Wrapper around cplus_demangle.  Strips leading underscores and
1740         other such chars that would otherwise confuse the demangler.
1741         If passed a g++ v3 ABI mangled name, returns a buffer allocated
1742         with malloc holding the demangled name.  Returns NULL otherwise
1743         and on memory alloc failure.
1744 */
1745
1746 char *
1747 bfd_demangle (bfd *abfd, const char *name, int options)
1748 {
1749   char *res, *alloc;
1750   const char *pre, *suf;
1751   size_t pre_len;
1752
1753   if (abfd != NULL
1754       && *name != '\0'
1755       && bfd_get_symbol_leading_char (abfd) == *name)
1756     ++name;
1757
1758   /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
1759      or the MS PE format.  These formats have a number of leading '.'s
1760      on at least some symbols, so we remove all dots to avoid
1761      confusing the demangler.  */
1762   pre = name;
1763   while (*name == '.' || *name == '$')
1764     ++name;
1765   pre_len = name - pre;
1766
1767   /* Strip off @plt and suchlike too.  */
1768   alloc = NULL;
1769   suf = strchr (name, '@');
1770   if (suf != NULL)
1771     {
1772       alloc = bfd_malloc (suf - name + 1);
1773       if (alloc == NULL)
1774         return NULL;
1775       memcpy (alloc, name, suf - name);
1776       alloc[suf - name] = '\0';
1777       name = alloc;
1778     }
1779
1780   res = cplus_demangle (name, options);
1781
1782   if (alloc != NULL)
1783     free (alloc);
1784
1785   if (res == NULL)
1786     return NULL;
1787
1788   /* Put back any prefix or suffix.  */
1789   if (pre_len != 0 || suf != NULL)
1790     {
1791       size_t len;
1792       size_t suf_len;
1793       char *final;
1794
1795       len = strlen (res);
1796       if (suf == NULL)
1797         suf = res + len;
1798       suf_len = strlen (suf) + 1;
1799       final = bfd_malloc (pre_len + len + suf_len);
1800       if (final != NULL)
1801         {
1802           memcpy (final, pre, pre_len);
1803           memcpy (final + pre_len, res, len);
1804           memcpy (final + pre_len + len, suf, suf_len);
1805         }
1806       free (res);
1807       res = final;
1808     }
1809
1810   return res;
1811 }