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