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