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