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
   4    Free Software Foundation, Inc.
   5    Written by Cygnus Support.
   6
   7 This file is part of BFD, the Binary File Descriptor library.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 /*
  24 SECTION
  25         <<typedef bfd>>
  26
  27         A BFD has type <<bfd>>; objects of this type are the
  28         cornerstone of any application using BFD. Using BFD
  29         consists of making references though the BFD and to data in the BFD.
  30
  31         Here is the structure that defines the type <<bfd>>.  It
  32         contains the major data about the file and pointers
  33         to the rest of the data.
  34
  35 CODE_FRAGMENT
  36 .
  37 .struct _bfd
  38 .{
  39 .    {* The filename the application opened the BFD with.  *}
  40 .    const char *filename;
  41 .
  42 .    {* A pointer to the target jump table.             *}
  43 .    const struct bfd_target *xvec;
  44 .
  45 .    {* To avoid dragging too many header files into every file that
  46 .       includes `<<bfd.h>>', IOSTREAM has been declared as a "char
  47 .       *", and MTIME as a "long".  Their correct types, to which they
  48 .       are cast when used, are "FILE *" and "time_t".    The iostream
  49 .       is the result of an fopen on the filename.  However, if the
  50 .       BFD_IN_MEMORY flag is set, then iostream is actually a pointer
  51 .       to a bfd_in_memory struct.  *}
  52 .    PTR iostream;
  53 .
  54 .    {* Is the file descriptor being cached?  That is, can it be closed as
  55 .       needed, and re-opened when accessed later?  *}
  56 .
  57 .    boolean cacheable;
  58 .
  59 .    {* Marks whether there was a default target specified when the
  60 .       BFD was opened. This is used to select which matching algorithm
  61 .       to use to choose the back end. *}
  62 .
  63 .    boolean target_defaulted;
  64 .
  65 .    {* The caching routines use these to maintain a
  66 .       least-recently-used list of BFDs *}
  67 .
  68 .    struct _bfd *lru_prev, *lru_next;
  69 .
  70 .    {* When a file is closed by the caching routines, BFD retains
  71 .       state information on the file here: *}
  72 .
  73 .    file_ptr where;
  74 .
  75 .    {* and here: (``once'' means at least once) *}
  76 .
  77 .    boolean opened_once;
  78 .
  79 .    {* Set if we have a locally maintained mtime value, rather than
  80 .       getting it from the file each time: *}
  81 .
  82 .    boolean mtime_set;
  83 .
  84 .    {* File modified time, if mtime_set is true: *}
  85 .
  86 .    long mtime;
  87 .
  88 .    {* Reserved for an unimplemented file locking extension.*}
  89 .
  90 .    int ifd;
  91 .
  92 .    {* The format which belongs to the BFD. (object, core, etc.) *}
  93 .
  94 .    bfd_format format;
  95 .
  96 .    {* The direction the BFD was opened with*}
  97 .
  98 .    enum bfd_direction {no_direction = 0,
  99 .                        read_direction = 1,
 100 .                        write_direction = 2,
 101 .                        both_direction = 3} direction;
 102 .
 103 .    {* Format_specific flags*}
 104 .
 105 .    flagword flags;
 106 .
 107 .    {* Currently my_archive is tested before adding origin to
 108 .       anything. I believe that this can become always an add of
 109 .       origin, with origin set to 0 for non archive files.   *}
 110 .
 111 .    file_ptr origin;
 112 .
 113 .    {* Remember when output has begun, to stop strange things
 114 .       from happening. *}
 115 .    boolean output_has_begun;
 116 .
 117 .    {* Pointer to linked list of sections*}
 118 .    struct sec  *sections;
 119 .
 120 .    {* The number of sections *}
 121 .    unsigned int section_count;
 122 .
 123 .    {* Stuff only useful for object files:
 124 .       The start address. *}
 125 .    bfd_vma start_address;
 126 .
 127 .    {* Used for input and output*}
 128 .    unsigned int symcount;
 129 .
 130 .    {* Symbol table for output BFD (with symcount entries) *}
 131 .    struct symbol_cache_entry  **outsymbols;
 132 .
 133 .    {* Pointer to structure which contains architecture information*}
 134 .    const struct bfd_arch_info *arch_info;
 135 .
 136 .    {* Stuff only useful for archives:*}
 137 .    PTR arelt_data;
 138 .    struct _bfd *my_archive;     {* The containing archive BFD.  *}
 139 .    struct _bfd *next;           {* The next BFD in the archive.  *}
 140 .    struct _bfd *archive_head;   {* The first BFD in the archive.  *}
 141 .    boolean has_armap;
 142 .
 143 .    {* A chain of BFD structures involved in a link.  *}
 144 .    struct _bfd *link_next;
 145 .
 146 .    {* A field used by _bfd_generic_link_add_archive_symbols.  This will
 147 .       be used only for archive elements.  *}
 148 .    int archive_pass;
 149 .
 150 .    {* Used by the back end to hold private data. *}
 151 .
 152 .    union
 153 .      {
 154 .      struct aout_data_struct *aout_data;
 155 .      struct artdata *aout_ar_data;
 156 .      struct _oasys_data *oasys_obj_data;
 157 .      struct _oasys_ar_data *oasys_ar_data;
 158 .      struct coff_tdata *coff_obj_data;
 159 .      struct pe_tdata *pe_obj_data;
 160 .      struct xcoff_tdata *xcoff_obj_data;
 161 .      struct ecoff_tdata *ecoff_obj_data;
 162 .      struct ieee_data_struct *ieee_data;
 163 .      struct ieee_ar_data_struct *ieee_ar_data;
 164 .      struct srec_data_struct *srec_data;
 165 .      struct ihex_data_struct *ihex_data;
 166 .      struct tekhex_data_struct *tekhex_data;
 167 .      struct elf_obj_tdata *elf_obj_data;
 168 .      struct nlm_obj_tdata *nlm_obj_data;
 169 .      struct bout_data_struct *bout_data;
 170 .      struct sun_core_struct *sun_core_data;
 171 .      struct sco5_core_struct *sco5_core_data;
 172 .      struct trad_core_struct *trad_core_data;
 173 .      struct som_data_struct *som_data;
 174 .      struct hpux_core_struct *hpux_core_data;
 175 .      struct hppabsd_core_struct *hppabsd_core_data;
 176 .      struct sgi_core_struct *sgi_core_data;
 177 .      struct lynx_core_struct *lynx_core_data;
 178 .      struct osf_core_struct *osf_core_data;
 179 .      struct cisco_core_struct *cisco_core_data;
 180 .      struct versados_data_struct *versados_data;
 181 .      struct netbsd_core_struct *netbsd_core_data;
 182 .      PTR any;
 183 .      } tdata;
 184 .
 185 .    {* Used by the application to hold private data*}
 186 .    PTR usrdata;
 187 .
 188 .  {* Where all the allocated stuff under this BFD goes.  This is a
 189 .     struct objalloc *, but we use PTR to avoid requiring the inclusion of
 190 .     objalloc.h.  *}
 191 .    PTR memory;
 192 .};
 193 .
 194 */
 195
 196 #include "bfd.h"
 197 #include "sysdep.h"
 198
 199 #ifdef ANSI_PROTOTYPES
 200 #include <stdarg.h>
 201 #else
 202 #include <varargs.h>
 203 #endif
 204
 205 #include "libiberty.h"
 206 #include "bfdlink.h"
 207 #include "libbfd.h"
 208 #include "coff/internal.h"
 209 #include "coff/sym.h"
 210 #include "libcoff.h"
 211 #include "libecoff.h"
 212 #undef obj_symbols
 213 #include "elf-bfd.h"
 214
 215 #include <ctype.h>
 216 \f
 217 /* provide storage for subsystem, stack and heap data which may have been
 218    passed in on the command line.  Ld puts this data into a bfd_link_info
 219    struct which ultimately gets passed in to the bfd.  When it arrives, copy
 220    it to the following struct so that the data will be available in coffcode.h
 221    where it is needed.  The typedef's used are defined in bfd.h */
 222 \f
 223 /*
 224 SECTION
 225         Error reporting
 226
 227         Most BFD functions return nonzero on success (check their
 228         individual documentation for precise semantics).  On an error,
 229         they call <<bfd_set_error>> to set an error condition that callers
 230         can check by calling <<bfd_get_error>>.
 231         If that returns <<bfd_error_system_call>>, then check
 232         <<errno>>.
 233
 234         The easiest way to report a BFD error to the user is to
 235         use <<bfd_perror>>.
 236
 237 SUBSECTION
 238         Type <<bfd_error_type>>
 239
 240         The values returned by <<bfd_get_error>> are defined by the
 241         enumerated type <<bfd_error_type>>.
 242
 243 CODE_FRAGMENT
 244 .
 245 .typedef enum bfd_error
 246 .{
 247 .  bfd_error_no_error = 0,
 248 .  bfd_error_system_call,
 249 .  bfd_error_invalid_target,
 250 .  bfd_error_wrong_format,
 251 .  bfd_error_invalid_operation,
 252 .  bfd_error_no_memory,
 253 .  bfd_error_no_symbols,
 254 .  bfd_error_no_armap,
 255 .  bfd_error_no_more_archived_files,
 256 .  bfd_error_malformed_archive,
 257 .  bfd_error_file_not_recognized,
 258 .  bfd_error_file_ambiguously_recognized,
 259 .  bfd_error_no_contents,
 260 .  bfd_error_nonrepresentable_section,
 261 .  bfd_error_no_debug_section,
 262 .  bfd_error_bad_value,
 263 .  bfd_error_file_truncated,
 264 .  bfd_error_file_too_big,
 265 .  bfd_error_invalid_error_code
 266 .} bfd_error_type;
 267 .
 268 */
 269
 270 static bfd_error_type bfd_error = bfd_error_no_error;
 271
 272 const char *const bfd_errmsgs[] =
 273 {
 274   N_("No error"),
 275   N_("System call error"),
 276   N_("Invalid bfd target"),
 277   N_("File in wrong format"),
 278   N_("Invalid operation"),
 279   N_("Memory exhausted"),
 280   N_("No symbols"),
 281   N_("Archive has no index; run ranlib to add one"),
 282   N_("No more archived files"),
 283   N_("Malformed archive"),
 284   N_("File format not recognized"),
 285   N_("File format is ambiguous"),
 286   N_("Section has no contents"),
 287   N_("Nonrepresentable section on output"),
 288   N_("Symbol needs debug section which does not exist"),
 289   N_("Bad value"),
 290   N_("File truncated"),
 291   N_("File too big"),
 292   N_("#<Invalid error code>")
 293 };
 294
 295 /*
 296 FUNCTION
 297         bfd_get_error
 298
 299 SYNOPSIS
 300         bfd_error_type bfd_get_error (void);
 301
 302 DESCRIPTION
 303         Return the current BFD error condition.
 304 */
 305
 306 bfd_error_type
 307 bfd_get_error ()
 308 {
 309   return bfd_error;
 310 }
 311
 312 /*
 313 FUNCTION
 314         bfd_set_error
 315
 316 SYNOPSIS
 317         void bfd_set_error (bfd_error_type error_tag);
 318
 319 DESCRIPTION
 320         Set the BFD error condition to be @var{error_tag}.
 321 */
 322
 323 void
 324 bfd_set_error (error_tag)
 325      bfd_error_type error_tag;
 326 {
 327   bfd_error = error_tag;
 328 }
 329
 330 /*
 331 FUNCTION
 332         bfd_errmsg
 333
 334 SYNOPSIS
 335         const char *bfd_errmsg (bfd_error_type error_tag);
 336
 337 DESCRIPTION
 338         Return a string describing the error @var{error_tag}, or
 339         the system error if @var{error_tag} is <<bfd_error_system_call>>.
 340 */
 341
 342 const char *
 343 bfd_errmsg (error_tag)
 344      bfd_error_type error_tag;
 345 {
 346 #ifndef errno
 347   extern int errno;
 348 #endif
 349   if (error_tag == bfd_error_system_call)
 350     return xstrerror (errno);
 351
 352   if ((((int) error_tag < (int) bfd_error_no_error) ||
 353        ((int) error_tag > (int) bfd_error_invalid_error_code)))
 354     error_tag = bfd_error_invalid_error_code;/* sanity check */
 355
 356   return _(bfd_errmsgs [(int)error_tag]);
 357 }
 358
 359 /*
 360 FUNCTION
 361         bfd_perror
 362
 363 SYNOPSIS
 364         void bfd_perror (const char *message);
 365
 366 DESCRIPTION
 367         Print to the standard error stream a string describing the
 368         last BFD error that occurred, or the last system error if
 369         the last BFD error was a system call failure.  If @var{message}
 370         is non-NULL and non-empty, the error string printed is preceded
 371         by @var{message}, a colon, and a space.  It is followed by a newline.
 372 */
 373
 374 void
 375 bfd_perror (message)
 376      const char *message;
 377 {
 378   if (bfd_get_error () == bfd_error_system_call)
 379     /* Must be a system error then.  */
 380     perror ((char *)message);
 381   else
 382     {
 383       if (message == NULL || *message == '\0')
 384         fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ()));
 385       else
 386         fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ()));
 387     }
 388 }
 389
 390 /*
 391 SUBSECTION
 392         BFD error handler
 393
 394         Some BFD functions want to print messages describing the
 395         problem.  They call a BFD error handler function.  This
 396         function may be overriden by the program.
 397
 398         The BFD error handler acts like printf.
 399
 400 CODE_FRAGMENT
 401 .
 402 .typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...));
 403 .
 404 */
 405
 406 /* The program name used when printing BFD error messages.  */
 407
 408 static const char *_bfd_error_program_name;
 409
 410 /* This is the default routine to handle BFD error messages.  */
 411
 412 #ifdef ANSI_PROTOTYPES
 413
 414 static void _bfd_default_error_handler PARAMS ((const char *s, ...));
 415
 416 static void
 417 _bfd_default_error_handler (const char *s, ...)
 418 {
 419   va_list p;
 420
 421   if (_bfd_error_program_name != NULL)
 422     fprintf (stderr, "%s: ", _bfd_error_program_name);
 423   else
 424     fprintf (stderr, "BFD: ");
 425
 426   va_start (p, s);
 427
 428   vfprintf (stderr, s, p);
 429
 430   va_end (p);
 431
 432   fprintf (stderr, "\n");
 433 }
 434
 435 #else /* ! defined (ANSI_PROTOTYPES) */
 436
 437 static void _bfd_default_error_handler ();
 438
 439 static void
 440 _bfd_default_error_handler (va_alist)
 441      va_dcl
 442 {
 443   va_list p;
 444   const char *s;
 445
 446   if (_bfd_error_program_name != NULL)
 447     fprintf (stderr, "%s: ", _bfd_error_program_name);
 448   else
 449     fprintf (stderr, "BFD: ");
 450
 451   va_start (p);
 452
 453   s = va_arg (p, const char *);
 454   vfprintf (stderr, s, p);
 455
 456   va_end (p);
 457
 458   fprintf (stderr, "\n");
 459 }
 460
 461 #endif /* ! defined (ANSI_PROTOTYPES) */
 462
 463 /* This is a function pointer to the routine which should handle BFD
 464    error messages.  It is called when a BFD routine encounters an
 465    error for which it wants to print a message.  Going through a
 466    function pointer permits a program linked against BFD to intercept
 467    the messages and deal with them itself.  */
 468
 469 bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler;
 470
 471 /*
 472 FUNCTION
 473         bfd_set_error_handler
 474
 475 SYNOPSIS
 476         bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
 477
 478 DESCRIPTION
 479         Set the BFD error handler function.  Returns the previous
 480         function.
 481 */
 482
 483 bfd_error_handler_type
 484 bfd_set_error_handler (pnew)
 485      bfd_error_handler_type pnew;
 486 {
 487   bfd_error_handler_type pold;
 488
 489   pold = _bfd_error_handler;
 490   _bfd_error_handler = pnew;
 491   return pold;
 492 }
 493
 494 /*
 495 FUNCTION
 496         bfd_set_error_program_name
 497
 498 SYNOPSIS
 499         void bfd_set_error_program_name (const char *);
 500
 501 DESCRIPTION
 502         Set the program name to use when printing a BFD error.  This
 503         is printed before the error message followed by a colon and
 504         space.  The string must not be changed after it is passed to
 505         this function.
 506 */
 507
 508 void
 509 bfd_set_error_program_name (name)
 510      const char *name;
 511 {
 512   _bfd_error_program_name = name;
 513 }
 514
 515 /*
 516 FUNCTION
 517         bfd_get_error_handler
 518
 519 SYNOPSIS
 520         bfd_error_handler_type bfd_get_error_handler (void);
 521
 522 DESCRIPTION
 523         Return the BFD error handler function.
 524 */
 525
 526 bfd_error_handler_type
 527 bfd_get_error_handler ()
 528 {
 529   return _bfd_error_handler;
 530 }
 531 \f
 532 /*
 533 SECTION
 534         Symbols
 535 */
 536
 537 /*
 538 FUNCTION
 539         bfd_get_reloc_upper_bound
 540
 541 SYNOPSIS
 542         long bfd_get_reloc_upper_bound(bfd *abfd, asection *sect);
 543
 544 DESCRIPTION
 545         Return the number of bytes required to store the
 546         relocation information associated with section @var{sect}
 547         attached to bfd @var{abfd}.  If an error occurs, return -1.
 548
 549 */
 550
 551 long
 552 bfd_get_reloc_upper_bound (abfd, asect)
 553      bfd *abfd;
 554      sec_ptr asect;
 555 {
 556   if (abfd->format != bfd_object)
 557     {
 558       bfd_set_error (bfd_error_invalid_operation);
 559       return -1;
 560     }
 561
 562   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 563 }
 564
 565 /*
 566 FUNCTION
 567         bfd_canonicalize_reloc
 568
 569 SYNOPSIS
 570         long bfd_canonicalize_reloc
 571                 (bfd *abfd,
 572                 asection *sec,
 573                 arelent **loc,
 574                 asymbol **syms);
 575
 576 DESCRIPTION
 577         Call the back end associated with the open BFD
 578         @var{abfd} and translate the external form of the relocation
 579         information attached to @var{sec} into the internal canonical
 580         form.  Place the table into memory at @var{loc}, which has
 581         been preallocated, usually by a call to
 582         <<bfd_get_reloc_upper_bound>>.  Returns the number of relocs, or
 583         -1 on error.
 584
 585         The @var{syms} table is also needed for horrible internal magic
 586         reasons.
 587
 588 */
 589 long
 590 bfd_canonicalize_reloc (abfd, asect, location, symbols)
 591      bfd *abfd;
 592      sec_ptr asect;
 593      arelent **location;
 594      asymbol **symbols;
 595 {
 596   if (abfd->format != bfd_object)
 597     {
 598       bfd_set_error (bfd_error_invalid_operation);
 599       return -1;
 600     }
 601
 602   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
 603                    (abfd, asect, location, symbols));
 604 }
 605
 606 /*
 607 FUNCTION
 608         bfd_set_reloc
 609
 610 SYNOPSIS
 611         void bfd_set_reloc
 612           (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
 613
 614 DESCRIPTION
 615         Set the relocation pointer and count within
 616         section @var{sec} to the values @var{rel} and @var{count}.
 617         The argument @var{abfd} is ignored.
 618
 619 */
 620
 621 void
 622 bfd_set_reloc (ignore_abfd, asect, location, count)
 623      bfd *ignore_abfd ATTRIBUTE_UNUSED;
 624      sec_ptr asect;
 625      arelent **location;
 626      unsigned int count;
 627 {
 628   asect->orelocation = location;
 629   asect->reloc_count = count;
 630 }
 631
 632 /*
 633 FUNCTION
 634         bfd_set_file_flags
 635
 636 SYNOPSIS
 637         boolean bfd_set_file_flags(bfd *abfd, flagword flags);
 638
 639 DESCRIPTION
 640         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
 641
 642         Possible errors are:
 643         o <<bfd_error_wrong_format>> - The target bfd was not of object format.
 644         o <<bfd_error_invalid_operation>> - The target bfd was open for reading.
 645         o <<bfd_error_invalid_operation>> -
 646         The flag word contained a bit which was not applicable to the
 647         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
 648         on a BFD format which does not support demand paging.
 649
 650 */
 651
 652 boolean
 653 bfd_set_file_flags (abfd, flags)
 654      bfd *abfd;
 655      flagword flags;
 656 {
 657   if (abfd->format != bfd_object)
 658     {
 659       bfd_set_error (bfd_error_wrong_format);
 660       return false;
 661     }
 662
 663   if (bfd_read_p (abfd))
 664     {
 665       bfd_set_error (bfd_error_invalid_operation);
 666       return false;
 667     }
 668
 669   bfd_get_file_flags (abfd) = flags;
 670   if ((flags & bfd_applicable_file_flags (abfd)) != flags)
 671     {
 672       bfd_set_error (bfd_error_invalid_operation);
 673       return false;
 674     }
 675
 676   return true;
 677 }
 678
 679 void
 680 bfd_assert (file, line)
 681      const char *file;
 682      int line;
 683 {
 684   (*_bfd_error_handler) (_("bfd assertion fail %s:%d"), file, line);
 685 }
 686
 687 /* A more or less friendly abort message.  In libbfd.h abort is
 688    defined to call this function.  */
 689
 690 #ifndef EXIT_FAILURE
 691 #define EXIT_FAILURE 1
 692 #endif
 693
 694 void
 695 _bfd_abort (file, line, fn)
 696      const char *file;
 697      int line;
 698      const char *fn;
 699 {
 700   if (fn != NULL)
 701     (*_bfd_error_handler)
 702       (_("BFD internal error, aborting at %s line %d in %s\n"),
 703        file, line, fn);
 704   else
 705     (*_bfd_error_handler)
 706       (_("BFD internal error, aborting at %s line %d\n"),
 707        file, line);
 708   (*_bfd_error_handler) (_("Please report this bug.\n"));
 709   xexit (EXIT_FAILURE);
 710 }
 711
 712 /*
 713 FUNCTION
 714         bfd_get_arch_size
 715
 716 SYNOPSIS
 717         int bfd_get_arch_size (bfd *abfd);
 718
 719 DESCRIPTION
 720         Returns the architecture address size, in bits, as determined
 721         by the object file's format.  For ELF, this information is
 722         included in the header.
 723
 724 RETURNS
 725         Returns the arch size in bits if known, <<-1>> otherwise.
 726 */
 727
 728 int
 729 bfd_get_arch_size (abfd)
 730      bfd *abfd;
 731 {
 732   if (abfd->xvec->flavour == bfd_target_elf_flavour)
 733     return (get_elf_backend_data (abfd))->s->arch_size;
 734
 735   bfd_set_error (bfd_error_wrong_format);
 736   return -1;
 737 }
 738
 739 /*
 740 FUNCTION
 741         bfd_get_sign_extend_vma
 742
 743 SYNOPSIS
 744         int bfd_get_sign_extend_vma (bfd *abfd);
 745
 746 DESCRIPTION
 747         Indicates if the target architecture "naturally" sign extends
 748         an address.  Some architectures implicitly sign extend address
 749         values when they are converted to types larger than the size
 750         of an address.  For instance, bfd_get_start_address() will
 751         return an address sign extended to fill a bfd_vma when this is
 752         the case.
 753
 754 RETURNS
 755         Returns <<1>> if the target architecture is known to sign
 756         extend addresses, <<0>> if the target architecture is known to
 757         not sign extend addresses, and <<-1>> otherwise.
 758 */
 759
 760 int
 761 bfd_get_sign_extend_vma (abfd)
 762      bfd *abfd;
 763 {
 764   char *name;
 765
 766   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 767     return (get_elf_backend_data (abfd)->sign_extend_vma);
 768
 769   name = bfd_get_target (abfd);
 770
 771   /* Return a proper value for DJGPP COFF (an x86 COFF variant).
 772      This function is required for DWARF2 support, but there is
 773      no place to store this information in the COFF back end.
 774      Should enough other COFF targets add support for DWARF2,
 775      a place will have to be found.  Until then, this hack will do.  */
 776   if (strncmp (name, "coff-go32", sizeof ("coff-go32") - 1) == 0)
 777     return 1;
 778
 779   bfd_set_error (bfd_error_wrong_format);
 780   return -1;
 781 }
 782
 783 /*
 784 FUNCTION
 785         bfd_set_start_address
 786
 787 SYNOPSIS
 788         boolean bfd_set_start_address(bfd *abfd, bfd_vma vma);
 789
 790 DESCRIPTION
 791         Make @var{vma} the entry point of output BFD @var{abfd}.
 792
 793 RETURNS
 794         Returns <<true>> on success, <<false>> otherwise.
 795 */
 796
 797 boolean
 798 bfd_set_start_address (abfd, vma)
 799      bfd *abfd;
 800      bfd_vma vma;
 801 {
 802   abfd->start_address = vma;
 803   return true;
 804 }
 805
 806 /*
 807 FUNCTION
 808         bfd_get_mtime
 809
 810 SYNOPSIS
 811         long bfd_get_mtime(bfd *abfd);
 812
 813 DESCRIPTION
 814         Return the file modification time (as read from the file system, or
 815         from the archive header for archive members).
 816
 817 */
 818
 819 long
 820 bfd_get_mtime (abfd)
 821      bfd *abfd;
 822 {
 823   FILE *fp;
 824   struct stat buf;
 825
 826   if (abfd->mtime_set)
 827     return abfd->mtime;
 828
 829   fp = bfd_cache_lookup (abfd);
 830   if (0 != fstat (fileno (fp), &buf))
 831     return 0;
 832
 833   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 834   return buf.st_mtime;
 835 }
 836
 837 /*
 838 FUNCTION
 839         bfd_get_size
 840
 841 SYNOPSIS
 842         long bfd_get_size(bfd *abfd);
 843
 844 DESCRIPTION
 845         Return the file size (as read from file system) for the file
 846         associated with BFD @var{abfd}.
 847
 848         The initial motivation for, and use of, this routine is not
 849         so we can get the exact size of the object the BFD applies to, since
 850         that might not be generally possible (archive members for example).
 851         It would be ideal if someone could eventually modify
 852         it so that such results were guaranteed.
 853
 854         Instead, we want to ask questions like "is this NNN byte sized
 855         object I'm about to try read from file offset YYY reasonable?"
 856         As as example of where we might do this, some object formats
 857         use string tables for which the first <<sizeof (long)>> bytes of the
 858         table contain the size of the table itself, including the size bytes.
 859         If an application tries to read what it thinks is one of these
 860         string tables, without some way to validate the size, and for
 861         some reason the size is wrong (byte swapping error, wrong location
 862         for the string table, etc.), the only clue is likely to be a read
 863         error when it tries to read the table, or a "virtual memory
 864         exhausted" error when it tries to allocate 15 bazillon bytes
 865         of space for the 15 bazillon byte table it is about to read.
 866         This function at least allows us to answer the quesion, "is the
 867         size reasonable?".
 868 */
 869
 870 long
 871 bfd_get_size (abfd)
 872      bfd *abfd;
 873 {
 874   FILE *fp;
 875   struct stat buf;
 876
 877   if ((abfd->flags & BFD_IN_MEMORY) != 0)
 878     return ((struct bfd_in_memory *) abfd->iostream)->size;
 879
 880   fp = bfd_cache_lookup (abfd);
 881   if (0 != fstat (fileno (fp), & buf))
 882     return 0;
 883
 884   return buf.st_size;
 885 }
 886
 887 /*
 888 FUNCTION
 889         bfd_get_gp_size
 890
 891 SYNOPSIS
 892         int bfd_get_gp_size(bfd *abfd);
 893
 894 DESCRIPTION
 895         Return the maximum size of objects to be optimized using the GP
 896         register under MIPS ECOFF.  This is typically set by the <<-G>>
 897         argument to the compiler, assembler or linker.
 898 */
 899
 900 int
 901 bfd_get_gp_size (abfd)
 902      bfd *abfd;
 903 {
 904   if (abfd->format == bfd_object)
 905     {
 906       if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 907         return ecoff_data (abfd)->gp_size;
 908       else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 909         return elf_gp_size (abfd);
 910     }
 911   return 0;
 912 }
 913
 914 /*
 915 FUNCTION
 916         bfd_set_gp_size
 917
 918 SYNOPSIS
 919         void bfd_set_gp_size(bfd *abfd, int i);
 920
 921 DESCRIPTION
 922         Set the maximum size of objects to be optimized using the GP
 923         register under ECOFF or MIPS ELF.  This is typically set by
 924         the <<-G>> argument to the compiler, assembler or linker.
 925 */
 926
 927 void
 928 bfd_set_gp_size (abfd, i)
 929      bfd *abfd;
 930      int i;
 931 {
 932   /* Don't try to set GP size on an archive or core file!  */
 933   if (abfd->format != bfd_object)
 934     return;
 935
 936   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 937     ecoff_data (abfd)->gp_size = i;
 938   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 939     elf_gp_size (abfd) = i;
 940 }
 941
 942 /* Get the GP value.  This is an internal function used by some of the
 943    relocation special_function routines on targets which support a GP
 944    register.  */
 945
 946 bfd_vma
 947 _bfd_get_gp_value (abfd)
 948      bfd *abfd;
 949 {
 950   if (abfd->format != bfd_object)
 951     return 0;
 952
 953   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 954     return ecoff_data (abfd)->gp;
 955   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 956     return elf_gp (abfd);
 957
 958   return 0;
 959 }
 960
 961 /* Set the GP value.  */
 962
 963 void
 964 _bfd_set_gp_value (abfd, v)
 965      bfd *abfd;
 966      bfd_vma v;
 967 {
 968   if (abfd->format != bfd_object)
 969     return;
 970
 971   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 972     ecoff_data (abfd)->gp = v;
 973   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 974     elf_gp (abfd) = v;
 975 }
 976
 977 /*
 978 FUNCTION
 979         bfd_scan_vma
 980
 981 SYNOPSIS
 982         bfd_vma bfd_scan_vma(const char *string, const char **end, int base);
 983
 984 DESCRIPTION
 985         Convert, like <<strtoul>>, a numerical expression
 986         @var{string} into a <<bfd_vma>> integer, and return that integer.
 987         (Though without as many bells and whistles as <<strtoul>>.)
 988         The expression is assumed to be unsigned (i.e., positive).
 989         If given a @var{base}, it is used as the base for conversion.
 990         A base of 0 causes the function to interpret the string
 991         in hex if a leading "0x" or "0X" is found, otherwise
 992         in octal if a leading zero is found, otherwise in decimal.
 993
 994         Overflow is not detected.
 995 */
 996
 997 bfd_vma
 998 bfd_scan_vma (string, end, base)
 999      const char *string;
1000      const char **end;
1001      int base;
1002 {
1003   bfd_vma value;
1004   int digit;
1005
1006   /* Let the host do it if possible.  */
1007   if (sizeof (bfd_vma) <= sizeof (unsigned long))
1008     return (bfd_vma) strtoul (string, (char **) end, base);
1009
1010   /* A negative base makes no sense, and we only need to go as high as hex.  */
1011   if ((base < 0) || (base > 16))
1012     return (bfd_vma) 0;
1013
1014   if (base == 0)
1015     {
1016       if (string[0] == '0')
1017         {
1018           if ((string[1] == 'x') || (string[1] == 'X'))
1019             base = 16;
1020           /* XXX should we also allow "0b" or "0B" to set base to 2?  */
1021           else
1022             base = 8;
1023         }
1024       else
1025         base = 10;
1026     }
1027
1028   if ((base == 16) &&
1029       (string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')))
1030     string += 2;
1031   /* XXX should we also skip over "0b" or "0B" if base is 2?  */
1032
1033 /* Speed could be improved with a table like hex_value[] in gas.  */
1034 #define HEX_VALUE(c) \
1035   (isxdigit ((unsigned char) c)                                 \
1036    ? (isdigit ((unsigned char) c)                               \
1037       ? (c - '0')                                               \
1038       : (10 + c - (islower ((unsigned char) c) ? 'a' : 'A')))   \
1039    : 42)
1040
1041   for (value = 0; (digit = HEX_VALUE (* string)) < base; string ++)
1042     value = value * base + digit;
1043
1044   if (end)
1045     * end = string;
1046
1047   return value;
1048 }
1049
1050 /*
1051 FUNCTION
1052         bfd_copy_private_bfd_data
1053
1054 SYNOPSIS
1055         boolean bfd_copy_private_bfd_data(bfd *ibfd, bfd *obfd);
1056
1057 DESCRIPTION
1058         Copy private BFD information from the BFD @var{ibfd} to the
1059         the BFD @var{obfd}.  Return <<true>> on success, <<false>> on error.
1060         Possible error returns are:
1061
1062         o <<bfd_error_no_memory>> -
1063         Not enough memory exists to create private data for @var{obfd}.
1064
1065 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
1066 .     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1067 .               (ibfd, obfd))
1068
1069 */
1070
1071 /*
1072 FUNCTION
1073         bfd_merge_private_bfd_data
1074
1075 SYNOPSIS
1076         boolean bfd_merge_private_bfd_data(bfd *ibfd, bfd *obfd);
1077
1078 DESCRIPTION
1079         Merge private BFD information from the BFD @var{ibfd} to the
1080         the output file BFD @var{obfd} when linking.  Return <<true>>
1081         on success, <<false>> on error.  Possible error returns are:
1082
1083         o <<bfd_error_no_memory>> -
1084         Not enough memory exists to create private data for @var{obfd}.
1085
1086 .#define bfd_merge_private_bfd_data(ibfd, obfd) \
1087 .     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1088 .               (ibfd, obfd))
1089
1090 */
1091
1092 /*
1093 FUNCTION
1094         bfd_set_private_flags
1095
1096 SYNOPSIS
1097         boolean bfd_set_private_flags(bfd *abfd, flagword flags);
1098
1099 DESCRIPTION
1100         Set private BFD flag information in the BFD @var{abfd}.
1101         Return <<true>> on success, <<false>> on error.  Possible error
1102         returns are:
1103
1104         o <<bfd_error_no_memory>> -
1105         Not enough memory exists to create private data for @var{obfd}.
1106
1107 .#define bfd_set_private_flags(abfd, flags) \
1108 .     BFD_SEND (abfd, _bfd_set_private_flags, \
1109 .               (abfd, flags))
1110
1111 */
1112
1113 /*
1114 FUNCTION
1115         stuff
1116
1117 DESCRIPTION
1118         Stuff which should be documented:
1119
1120 .#define bfd_sizeof_headers(abfd, reloc) \
1121 .     BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
1122 .
1123 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1124 .     BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
1125 .
1126 .       {* Do these three do anything useful at all, for any back end?  *}
1127 .#define bfd_debug_info_start(abfd) \
1128 .        BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1129 .
1130 .#define bfd_debug_info_end(abfd) \
1131 .        BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1132 .
1133 .#define bfd_debug_info_accumulate(abfd, section) \
1134 .        BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1135 .
1136 .
1137 .#define bfd_stat_arch_elt(abfd, stat) \
1138 .        BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1139 .
1140 .#define bfd_update_armap_timestamp(abfd) \
1141 .        BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1142 .
1143 .#define bfd_set_arch_mach(abfd, arch, mach)\
1144 .        BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1145 .
1146 .#define bfd_relax_section(abfd, section, link_info, again) \
1147 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1148 .
1149 .#define bfd_gc_sections(abfd, link_info) \
1150 .       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1151 .
1152 .#define bfd_merge_sections(abfd, link_info) \
1153 .       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1154 .
1155 .#define bfd_link_hash_table_create(abfd) \
1156 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1157 .
1158 .#define bfd_link_add_symbols(abfd, info) \
1159 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1160 .
1161 .#define bfd_final_link(abfd, info) \
1162 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1163 .
1164 .#define bfd_free_cached_info(abfd) \
1165 .       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1166 .
1167 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1168 .       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1169 .
1170 .#define bfd_print_private_bfd_data(abfd, file)\
1171 .       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1172 .
1173 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1174 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1175 .
1176 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1177 .       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1178 .
1179 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1180 .       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1181 .
1182 .extern bfd_byte *bfd_get_relocated_section_contents
1183 .       PARAMS ((bfd *, struct bfd_link_info *,
1184 .                 struct bfd_link_order *, bfd_byte *,
1185 .                 boolean, asymbol **));
1186 .
1187
1188 */
1189
1190 bfd_byte *
1191 bfd_get_relocated_section_contents (abfd, link_info, link_order, data,
1192                                     relocateable, symbols)
1193      bfd *abfd;
1194      struct bfd_link_info *link_info;
1195      struct bfd_link_order *link_order;
1196      bfd_byte *data;
1197      boolean relocateable;
1198      asymbol **symbols;
1199 {
1200   bfd *abfd2;
1201   bfd_byte *(*fn) PARAMS ((bfd *, struct bfd_link_info *,
1202                            struct bfd_link_order *, bfd_byte *, boolean,
1203                            asymbol **));
1204
1205   if (link_order->type == bfd_indirect_link_order)
1206     {
1207       abfd2 = link_order->u.indirect.section->owner;
1208       if (abfd2 == NULL)
1209         abfd2 = abfd;
1210     }
1211   else
1212     abfd2 = abfd;
1213
1214   fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1215
1216   return (*fn) (abfd, link_info, link_order, data, relocateable, symbols);
1217 }
1218
1219 /* Record information about an ELF program header.  */
1220
1221 boolean
1222 bfd_record_phdr (abfd, type, flags_valid, flags, at_valid, at,
1223                  includes_filehdr, includes_phdrs, count, secs)
1224      bfd *abfd;
1225      unsigned long type;
1226      boolean flags_valid;
1227      flagword flags;
1228      boolean at_valid;
1229      bfd_vma at;
1230      boolean includes_filehdr;
1231      boolean includes_phdrs;
1232      unsigned int count;
1233      asection **secs;
1234 {
1235   struct elf_segment_map *m, **pm;
1236
1237   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1238     return true;
1239
1240   m = ((struct elf_segment_map *)
1241        bfd_alloc (abfd,
1242                   (sizeof (struct elf_segment_map)
1243                    + ((size_t) count - 1) * sizeof (asection *))));
1244   if (m == NULL)
1245     return false;
1246
1247   m->next = NULL;
1248   m->p_type = type;
1249   m->p_flags = flags;
1250   m->p_paddr = at;
1251   m->p_flags_valid = flags_valid;
1252   m->p_paddr_valid = at_valid;
1253   m->includes_filehdr = includes_filehdr;
1254   m->includes_phdrs = includes_phdrs;
1255   m->count = count;
1256   if (count > 0)
1257     memcpy (m->sections, secs, count * sizeof (asection *));
1258
1259   for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
1260     ;
1261   *pm = m;
1262
1263   return true;
1264 }
1265
1266 void
1267 bfd_sprintf_vma (abfd, buf, value)
1268      bfd *abfd;
1269      char *buf;
1270      bfd_vma value;
1271 {
1272   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1273     return bfd_elf_sprintf_vma (abfd, buf, value);
1274   sprintf_vma (buf, value);
1275 }
1276
1277 void
1278 bfd_fprintf_vma (abfd, stream, value)
1279      bfd *abfd;
1280      PTR stream;
1281      bfd_vma value;
1282 {
1283   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1284     return bfd_elf_fprintf_vma (abfd, stream, value);
1285   fprintf_vma ((FILE *) stream, value);
1286 }