bfd/bfd.c

   1 /* Generic BFD library interface and support routines.
   2    Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Written by Cygnus Support.
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /*
  22 SECTION
  23         <<typedef bfd>>
  24
  25         A BFD has type <<bfd>>; objects of this type are the
  26         cornerstone of any application using BFD. Using BFD
  27         consists of making references though the BFD and to data in the BFD.
  28
  29         Here is the structure that defines the type <<bfd>>.  It
  30         contains the major data about the file and pointers
  31         to the rest of the data.
  32
  33 CODE_FRAGMENT
  34 .
  35 .struct _bfd
  36 .{
  37 .    {* The filename the application opened the BFD with.  *}
  38 .    CONST char *filename;
  39 .
  40 .    {* A pointer to the target jump table.             *}
  41 .    struct bfd_target *xvec;
  42 .
  43 .    {* To avoid dragging too many header files into every file that
  44 .       includes `<<bfd.h>>', IOSTREAM has been declared as a "char
  45 .       *", and MTIME as a "long".  Their correct types, to which they
  46 .       are cast when used, are "FILE *" and "time_t".    The iostream
  47 .       is the result of an fopen on the filename. *}
  48 .    char *iostream;
  49 .
  50 .    {* Is the file descriptor being cached?  That is, can it be closed as
  51 .       needed, and re-opened when accessed later?  *}
  52 .
  53 .    boolean cacheable;
  54 .
  55 .    {* Marks whether there was a default target specified when the
  56 .       BFD was opened. This is used to select which matching algorithm
  57 .       to use to choose the back end. *}
  58 .
  59 .    boolean target_defaulted;
  60 .
  61 .    {* The caching routines use these to maintain a
  62 .       least-recently-used list of BFDs *}
  63 .
  64 .    struct _bfd *lru_prev, *lru_next;
  65 .
  66 .    {* When a file is closed by the caching routines, BFD retains
  67 .       state information on the file here: *}
  68 .
  69 .    file_ptr where;
  70 .
  71 .    {* and here: (``once'' means at least once) *}
  72 .
  73 .    boolean opened_once;
  74 .
  75 .    {* Set if we have a locally maintained mtime value, rather than
  76 .       getting it from the file each time: *}
  77 .
  78 .    boolean mtime_set;
  79 .
  80 .    {* File modified time, if mtime_set is true: *}
  81 .
  82 .    long mtime;
  83 .
  84 .    {* Reserved for an unimplemented file locking extension.*}
  85 .
  86 .    int ifd;
  87 .
  88 .    {* The format which belongs to the BFD. (object, core, etc.) *}
  89 .
  90 .    bfd_format format;
  91 .
  92 .    {* The direction the BFD was opened with*}
  93 .
  94 .    enum bfd_direction {no_direction = 0,
  95 .                        read_direction = 1,
  96 .                        write_direction = 2,
  97 .                        both_direction = 3} direction;
  98 .
  99 .    {* Format_specific flags*}
 100 .
 101 .    flagword flags;
 102 .
 103 .    {* Currently my_archive is tested before adding origin to
 104 .       anything. I believe that this can become always an add of
 105 .       origin, with origin set to 0 for non archive files.   *}
 106 .
 107 .    file_ptr origin;
 108 .
 109 .    {* Remember when output has begun, to stop strange things
 110 .       from happening. *}
 111 .    boolean output_has_begun;
 112 .
 113 .    {* Pointer to linked list of sections*}
 114 .    struct sec  *sections;
 115 .
 116 .    {* The number of sections *}
 117 .    unsigned int section_count;
 118 .
 119 .    {* Stuff only useful for object files:
 120 .       The start address. *}
 121 .    bfd_vma start_address;
 122 .
 123 .    {* Used for input and output*}
 124 .    unsigned int symcount;
 125 .
 126 .    {* Symbol table for output BFD (with symcount entries) *}
 127 .    struct symbol_cache_entry  **outsymbols;
 128 .
 129 .    {* Pointer to structure which contains architecture information*}
 130 .    struct bfd_arch_info *arch_info;
 131 .
 132 .    {* Stuff only useful for archives:*}
 133 .    PTR arelt_data;
 134 .    struct _bfd *my_archive;     {* The containing archive BFD.  *}
 135 .    struct _bfd *next;           {* The next BFD in the archive.  *}
 136 .    struct _bfd *archive_head;   {* The first BFD in the archive.  *}
 137 .    boolean has_armap;
 138 .
 139 .    {* A chain of BFD structures involved in a link.  *}
 140 .    struct _bfd *link_next;
 141 .
 142 .    {* A field used by _bfd_generic_link_add_archive_symbols.  This will
 143 .       be used only for archive elements.  *}
 144 .    int archive_pass;
 145 .
 146 .    {* Used by the back end to hold private data. *}
 147 .
 148 .    union
 149 .      {
 150 .      struct aout_data_struct *aout_data;
 151 .      struct artdata *aout_ar_data;
 152 .      struct _oasys_data *oasys_obj_data;
 153 .      struct _oasys_ar_data *oasys_ar_data;
 154 .      struct coff_tdata *coff_obj_data;
 155 .      struct ecoff_tdata *ecoff_obj_data;
 156 .      struct ieee_data_struct *ieee_data;
 157 .      struct ieee_ar_data_struct *ieee_ar_data;
 158 .      struct srec_data_struct *srec_data;
 159 .      struct tekhex_data_struct *tekhex_data;
 160 .      struct elf_obj_tdata *elf_obj_data;
 161 .      struct nlm_obj_tdata *nlm_obj_data;
 162 .      struct bout_data_struct *bout_data;
 163 .      struct sun_core_struct *sun_core_data;
 164 .      struct trad_core_struct *trad_core_data;
 165 .      struct som_data_struct *som_data;
 166 .      struct hpux_core_struct *hpux_core_data;
 167 .      struct hppabsd_core_struct *hppabsd_core_data;
 168 .      struct sgi_core_struct *sgi_core_data;
 169 .      struct lynx_core_struct *lynx_core_data;
 170 .      struct osf_core_struct *osf_core_data;
 171 .      PTR any;
 172 .      } tdata;
 173 .
 174 .    {* Used by the application to hold private data*}
 175 .    PTR usrdata;
 176 .
 177 .    {* Where all the allocated stuff under this BFD goes *}
 178 .    struct obstack memory;
 179 .};
 180 .
 181 */
 182
 183 #include "bfd.h"
 184 #include "sysdep.h"
 185 #include "bfdlink.h"
 186 #include "libbfd.h"
 187 #include "coff/internal.h"
 188 #include "coff/sym.h"
 189 #include "libcoff.h"
 190 #include "libecoff.h"
 191 #undef obj_symbols
 192 #include "libelf.h"
 193
 194 #undef strerror
 195 extern char *strerror();
 196
 197 /** Error handling
 198     o - Most functions return nonzero on success (check doc for
 199         precise semantics); 0 or NULL on error.
 200     o - Internal errors are documented by the value of bfd_error.
 201         If that is system_call_error then check errno.
 202     o - The easiest way to report this to the user is to use bfd_perror.
 203 */
 204
 205 bfd_ec bfd_error = no_error;
 206
 207 CONST char *CONST bfd_errmsgs[] = {
 208                         "No error",
 209                         "System call error",
 210                         "Invalid bfd target",
 211                         "File in wrong format",
 212                         "Invalid operation",
 213                         "Memory exhausted",
 214                         "No symbols",
 215                         "No relocation info",
 216                         "No more archived files",
 217                         "Malformed archive",
 218                         "Symbol not found",
 219                         "File format not recognized",
 220                         "File format is ambiguous",
 221                         "Section has no contents",
 222                         "Nonrepresentable section on output",
 223                         "Symbol needs debug section which does not exist",
 224                         "Bad value",
 225                         "File truncated",
 226                         "#<Invalid error code>"
 227                        };
 228
 229 CONST char *
 230 bfd_errmsg (error_tag)
 231      bfd_ec error_tag;
 232 {
 233 #ifndef errno
 234   extern int errno;
 235 #endif
 236   if (error_tag == system_call_error)
 237     return strerror (errno);
 238
 239   if ((((int)error_tag <(int) no_error) ||
 240        ((int)error_tag > (int)invalid_error_code)))
 241     error_tag = invalid_error_code;/* sanity check */
 242
 243   return bfd_errmsgs [(int)error_tag];
 244 }
 245
 246 void
 247 DEFUN(bfd_perror,(message),
 248       CONST char *message)
 249 {
 250   if (bfd_error == system_call_error)
 251     perror((char *)message);            /* must be system error then... */
 252   else {
 253     if (message == NULL || *message == '\0')
 254       fprintf (stderr, "%s\n", bfd_errmsg (bfd_error));
 255     else
 256       fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_error));
 257   }
 258 }
 259
 260  \f
 261 /** Symbols */
 262
 263
 264 /*
 265 FUNCTION
 266         bfd_get_reloc_upper_bound
 267
 268 SYNOPSIS
 269         unsigned int bfd_get_reloc_upper_bound(bfd *abfd, asection *sect);
 270
 271 DESCRIPTION
 272         Return the number of bytes required to store the
 273         relocation information associated with section @var{sect}
 274         attached to bfd @var{abfd}.
 275
 276 */
 277
 278
 279 unsigned int
 280 DEFUN(bfd_get_reloc_upper_bound,(abfd, asect),
 281      bfd *abfd AND
 282      sec_ptr asect)
 283 {
 284   if (abfd->format != bfd_object) {
 285     bfd_error = invalid_operation;
 286     return 0;
 287   }
 288
 289   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 290 }
 291
 292 /*
 293 FUNCTION
 294         bfd_canonicalize_reloc
 295
 296 SYNOPSIS
 297         unsigned int bfd_canonicalize_reloc
 298                 (bfd *abfd,
 299                 asection *sec,
 300                 arelent **loc,
 301                 asymbol **syms);
 302
 303 DESCRIPTION
 304         Call the back end associated with the open BFD
 305         @var{abfd} and translate the external form of the relocation
 306         information attached to @var{sec} into the internal canonical
 307         form.  Place the table into memory at @var{loc}, which has
 308         been preallocated, usually by a call to
 309         <<bfd_get_reloc_upper_bound>>.
 310
 311         The @var{syms} table is also needed for horrible internal magic
 312         reasons.
 313
 314
 315 */
 316 unsigned int
 317 DEFUN(bfd_canonicalize_reloc,(abfd, asect, location, symbols),
 318      bfd *abfd AND
 319      sec_ptr asect AND
 320      arelent **location AND
 321      asymbol **symbols)
 322 {
 323   if (abfd->format != bfd_object) {
 324     bfd_error = invalid_operation;
 325     return 0;
 326   }
 327   return BFD_SEND (abfd, _bfd_canonicalize_reloc,
 328                    (abfd, asect, location, symbols));
 329 }
 330
 331 /*
 332 FUNCTION
 333         bfd_set_reloc
 334
 335 SYNOPSIS
 336         void bfd_set_reloc
 337           (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
 338
 339 DESCRIPTION
 340         Set the relocation pointer and count within
 341         section @var{sec} to the values @var{rel} and @var{count}.
 342         The argument @var{abfd} is ignored.
 343
 344 */
 345 /*ARGSUSED*/
 346 void
 347 bfd_set_reloc (ignore_abfd, asect, location, count)
 348      bfd *ignore_abfd;
 349      sec_ptr asect;
 350      arelent **location;
 351      unsigned int count;
 352 {
 353   asect->orelocation  = location;
 354   asect->reloc_count = count;
 355 }
 356
 357 /*
 358 FUNCTION
 359         bfd_set_file_flags
 360
 361 SYNOPSIS
 362         boolean bfd_set_file_flags(bfd *abfd, flagword flags);
 363
 364 DESCRIPTION
 365         Set the flag word in the BFD @var{abfd} to the value @var{flags}.
 366
 367         Possible errors are:
 368         o <<wrong_format>> - The target bfd was not of object format.
 369         o <<invalid_operation>> - The target bfd was open for reading.
 370         o <<invalid_operation>> -
 371         The flag word contained a bit which was not applicable to the
 372         type of file.  E.g., an attempt was made to set the <<D_PAGED>> bit
 373         on a BFD format which does not support demand paging.
 374
 375 */
 376
 377 boolean
 378 bfd_set_file_flags (abfd, flags)
 379      bfd *abfd;
 380      flagword flags;
 381 {
 382   if (abfd->format != bfd_object) {
 383     bfd_error = wrong_format;
 384     return false;
 385   }
 386
 387   if (bfd_read_p (abfd)) {
 388     bfd_error = invalid_operation;
 389     return false;
 390   }
 391
 392   bfd_get_file_flags (abfd) = flags;
 393   if ((flags & bfd_applicable_file_flags (abfd)) != flags) {
 394     bfd_error = invalid_operation;
 395     return false;
 396   }
 397
 398 return true;
 399 }
 400
 401 void
 402 bfd_assert(file, line)
 403 char *file;
 404 int line;
 405 {
 406   fprintf(stderr, "bfd assertion fail %s:%d\n",file,line);
 407 }
 408
 409
 410 /*
 411 FUNCTION
 412         bfd_set_start_address
 413
 414 SYNOPSIS
 415         boolean bfd_set_start_address(bfd *abfd, bfd_vma vma);
 416
 417 DESCRIPTION
 418         Make @var{vma} the entry point of output BFD @var{abfd}.
 419
 420 RETURNS
 421         Returns <<true>> on success, <<false>> otherwise.
 422 */
 423
 424 boolean
 425 bfd_set_start_address(abfd, vma)
 426 bfd *abfd;
 427 bfd_vma vma;
 428 {
 429   abfd->start_address = vma;
 430   return true;
 431 }
 432
 433
 434 /*
 435 FUNCTION
 436         bfd_get_mtime
 437
 438 SYNOPSIS
 439         long bfd_get_mtime(bfd *abfd);
 440
 441 DESCRIPTION
 442         Return the file modification time (as read from the file system, or
 443         from the archive header for archive members).
 444
 445 */
 446
 447 long
 448 bfd_get_mtime (abfd)
 449      bfd *abfd;
 450 {
 451   FILE *fp;
 452   struct stat buf;
 453
 454   if (abfd->mtime_set)
 455     return abfd->mtime;
 456
 457   fp = bfd_cache_lookup (abfd);
 458   if (0 != fstat (fileno (fp), &buf))
 459     return 0;
 460
 461   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 462   return buf.st_mtime;
 463 }
 464
 465 /*
 466 FUNCTION
 467         bfd_get_size
 468
 469 SYNOPSIS
 470         long bfd_get_size(bfd *abfd);
 471
 472 DESCRIPTION
 473         Return the file size (as read from file system) for the file
 474         associated with BFD @var{abfd}.
 475
 476         The initial motivation for, and use of, this routine is not
 477         so we can get the exact size of the object the BFD applies to, since
 478         that might not be generally possible (archive members for example).
 479         It would be ideal if someone could eventually modify
 480         it so that such results were guaranteed.
 481
 482         Instead, we want to ask questions like "is this NNN byte sized
 483         object I'm about to try read from file offset YYY reasonable?"
 484         As as example of where we might do this, some object formats
 485         use string tables for which the first <<sizeof(long)>> bytes of the
 486         table contain the size of the table itself, including the size bytes.
 487         If an application tries to read what it thinks is one of these
 488         string tables, without some way to validate the size, and for
 489         some reason the size is wrong (byte swapping error, wrong location
 490         for the string table, etc.), the only clue is likely to be a read
 491         error when it tries to read the table, or a "virtual memory
 492         exhausted" error when it tries to allocate 15 bazillon bytes
 493         of space for the 15 bazillon byte table it is about to read.
 494         This function at least allows us to answer the quesion, "is the
 495         size reasonable?".
 496 */
 497
 498 long
 499 bfd_get_size (abfd)
 500      bfd *abfd;
 501 {
 502   FILE *fp;
 503   struct stat buf;
 504
 505   fp = bfd_cache_lookup (abfd);
 506   if (0 != fstat (fileno (fp), &buf))
 507     return 0;
 508
 509   return buf.st_size;
 510 }
 511
 512 /*
 513 FUNCTION
 514         bfd_get_gp_size
 515
 516 SYNOPSIS
 517         int bfd_get_gp_size(bfd *abfd);
 518
 519 DESCRIPTION
 520         Return the maximum size of objects to be optimized using the GP
 521         register under MIPS ECOFF.  This is typically set by the <<-G>>
 522         argument to the compiler, assembler or linker.
 523 */
 524
 525 int
 526 bfd_get_gp_size (abfd)
 527      bfd *abfd;
 528 {
 529   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 530     return ecoff_data (abfd)->gp_size;
 531   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 532     return elf_gp_size (abfd);
 533   return 0;
 534 }
 535
 536 /*
 537 FUNCTION
 538         bfd_set_gp_size
 539
 540 SYNOPSIS
 541         void bfd_set_gp_size(bfd *abfd, int i);
 542
 543 DESCRIPTION
 544         Set the maximum size of objects to be optimized using the GP
 545         register under ECOFF or MIPS ELF.  This is typically set by
 546         the <<-G>> argument to the compiler, assembler or linker.
 547 */
 548
 549 void
 550 bfd_set_gp_size (abfd, i)
 551      bfd *abfd;
 552      int i;
 553 {
 554   if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
 555     ecoff_data (abfd)->gp_size = i;
 556   else if (abfd->xvec->flavour == bfd_target_elf_flavour)
 557     elf_gp_size (abfd) = i;
 558 }
 559
 560 /*
 561 FUNCTION
 562         bfd_scan_vma
 563
 564 SYNOPSIS
 565         bfd_vma bfd_scan_vma(CONST char *string, CONST char **end, int base);
 566
 567 DESCRIPTION
 568         Convert, like <<strtoul>>, a numerical expression
 569         @var{string} into a <<bfd_vma>> integer, and return that integer.
 570         (Though without as many bells and whistles as <<strtoul>>.)
 571         The expression is assumed to be unsigned (i.e., positive).
 572         If given a @var{base}, it is used as the base for conversion.
 573         A base of 0 causes the function to interpret the string
 574         in hex if a leading "0x" or "0X" is found, otherwise
 575         in octal if a leading zero is found, otherwise in decimal.
 576
 577         Overflow is not detected.
 578 */
 579
 580 bfd_vma
 581 DEFUN(bfd_scan_vma,(string, end, base),
 582       CONST char *string AND
 583       CONST char **end AND
 584       int base)
 585 {
 586   bfd_vma value;
 587   int digit;
 588
 589   /* Let the host do it if possible.  */
 590   if (sizeof(bfd_vma) <= sizeof(unsigned long))
 591     return (bfd_vma) strtoul (string, 0, base);
 592
 593   /* A negative base makes no sense, and we only need to go as high as hex.  */
 594   if ((base < 0) || (base > 16))
 595     return (bfd_vma) 0;
 596
 597   if (base == 0)
 598     {
 599       if (string[0] == '0')
 600         {
 601           if ((string[1] == 'x') || (string[1] == 'X'))
 602             base = 16;
 603           /* XXX should we also allow "0b" or "0B" to set base to 2? */
 604           else
 605             base = 8;
 606         }
 607       else
 608         base = 10;
 609     }
 610   if ((base == 16) &&
 611       (string[0] == '0') && ((string[1] == 'x') || (string[1] == 'X')))
 612     string += 2;
 613   /* XXX should we also skip over "0b" or "0B" if base is 2? */
 614
 615 /* Speed could be improved with a table like hex_value[] in gas.  */
 616 #define HEX_VALUE(c) \
 617   (isxdigit(c) ?                                \
 618     (isdigit(c) ?                               \
 619       (c - '0') :                               \
 620       (10 + c - (islower(c) ? 'a' : 'A'))) :    \
 621     42)
 622
 623   for (value = 0; (digit = HEX_VALUE(*string)) < base; string++)
 624     {
 625       value = value * base + digit;
 626     }
 627
 628   if (end)
 629     *end = string;
 630
 631   return value;
 632 }
 633
 634 /*
 635 FUNCTION
 636         stuff
 637
 638 DESCRIPTION
 639         Stuff which should be documented:
 640
 641 .#define bfd_sizeof_headers(abfd, reloc) \
 642 .     BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
 643 .
 644 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
 645 .     BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
 646 .
 647 .       {* Do these three do anything useful at all, for any back end?  *}
 648 .#define bfd_debug_info_start(abfd) \
 649 .        BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
 650 .
 651 .#define bfd_debug_info_end(abfd) \
 652 .        BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
 653 .
 654 .#define bfd_debug_info_accumulate(abfd, section) \
 655 .        BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
 656 .
 657 .
 658 .#define bfd_stat_arch_elt(abfd, stat) \
 659 .        BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
 660 .
 661 .#define bfd_set_arch_mach(abfd, arch, mach)\
 662 .        BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
 663 .
 664 .#define bfd_get_relocated_section_contents(abfd, link_info, link_order, data, relocateable, symbols) \
 665 .       BFD_SEND (abfd, _bfd_get_relocated_section_contents, \
 666 .                 (abfd, link_info, link_order, data, relocateable, symbols))
 667 .
 668 .#define bfd_relax_section(abfd, section, link_info, symbols) \
 669 .       BFD_SEND (abfd, _bfd_relax_section, \
 670 .                 (abfd, section, link_info, symbols))
 671 .
 672 .#define bfd_link_hash_table_create(abfd) \
 673 .       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
 674 .
 675 .#define bfd_link_add_symbols(abfd, info) \
 676 .       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
 677 .
 678 .#define bfd_final_link(abfd, info) \
 679 .       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
 680 .
 681
 682 */