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