bfd/bfd.c

   1 /* Generic BFD library interface and support routines.
   2    Copyright (C) 1990-1991 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 /* $Id$ */
  22
  23 /*
  24 SECTION
  25         <<typedef bfd>>
  26
  27         A BFD is has type <<bfd>>; objects of this type are the
  28         cornerstone of any application using <<libbfd>>. References
  29         though the BFD and to data in the BFD give the entire BFD
  30         functionality.
  31
  32         Here is the struct used to define the type <<bfd>>.  This
  33         contains he major data about the file, and contains pointers
  34         to the rest of the data.
  35
  36 CODE_FRAGMENT
  37 .
  38 .struct _bfd
  39 .{
  40 .    {* The filename the application opened the BFD with.  *}
  41 .    CONST char *filename;
  42 .
  43 .    {* A pointer to the target jump table.             *}
  44 .    struct bfd_target *xvec;
  45 .
  46 .    {* To avoid dragging too many header files into every file that
  47 .       includes @file{bfd.h}, IOSTREAM has been declared as a "char
  48 .       *", and MTIME as a "long".  Their correct types, to which they
  49 .       are cast when used, are "FILE *" and "time_t".    The iostream
  50 .       is the result of an fopen on the filename. *}
  51 .    char *iostream;
  52 .
  53 .    {* Is the file being cached *}
  54 .
  55 .    boolean cacheable;
  56 .
  57 .    {* Marks whether there was a default target specified when the
  58 .       BFD was opened. This is used to select what matching algorithm
  59 .       to use to chose the back end. *}
  60 .
  61 .    boolean target_defaulted;
  62 .
  63 .    {* The caching routines use these to maintain a
  64 .       least-recently-used list of BFDs *}
  65 .
  66 .    struct _bfd *lru_prev, *lru_next;
  67 .
  68 .    {* When a file is closed by the caching routines, BFD retains
  69 .       state information on the file here:
  70 .     *}
  71 .
  72 .    file_ptr where;
  73 .
  74 .    {* and here:*}
  75 .
  76 .    boolean opened_once;
  77 .
  78 .    {* Set if we have a locally maintained mtime value, rather than
  79 .       getting it from the file each time: *}
  80 .
  81 .    boolean mtime_set;
  82 .
  83 .    {* File modified time, if mtime_set is true: *}
  84 .
  85 .    long mtime;
  86 .
  87 .    {* Reserved for an unimplemented file locking extension.*}
  88 .
  89 .    int ifd;
  90 .
  91 .    {* The format which belongs to the BFD.*}
  92 .
  93 .    bfd_format format;
  94 .
  95 .    {* The direction the BFD was opened with*}
  96 .
  97 .    enum bfd_direction {no_direction = 0,
  98 .                        read_direction = 1,
  99 .                        write_direction = 2,
 100 .                        both_direction = 3} direction;
 101 .
 102 .    {* Format_specific flags*}
 103 .
 104 .    flagword flags;
 105 .
 106 .    {* Currently my_archive is tested before adding origin to
 107 .       anything. I believe that this can become always an add of
 108 .       origin, with origin set to 0 for non archive files.   *}
 109 .
 110 .    file_ptr origin;
 111 .
 112 .    {* Remember when output has begun, to stop strange things
 113 .       happening. *}
 114 .    boolean output_has_begun;
 115 .
 116 .    {* Pointer to linked list of sections*}
 117 .    struct sec  *sections;
 118 .
 119 .    {* The number of sections *}
 120 .    unsigned int section_count;
 121 .
 122 .    {* Stuff only useful for object files:
 123 .       The start address. *}
 124 .    bfd_vma start_address;
 125 .
 126 .    {* Used for input and output*}
 127 .    unsigned int symcount;
 128 .
 129 .    {* Symbol table for output BFD*}
 130 .    struct symbol_cache_entry  **outsymbols;
 131 .
 132 .    {* Pointer to structure which contains architecture information*}
 133 .    struct bfd_arch_info *arch_info;
 134 .
 135 .    {* Stuff only useful for archives:*}
 136 .    PTR arelt_data;
 137 .    struct _bfd *my_archive;
 138 .    struct _bfd *next;
 139 .    struct _bfd *archive_head;
 140 .    boolean has_armap;
 141 .
 142 .    {* Used by the back end to hold private data. *}
 143 .
 144 .    union
 145 .      {
 146 .      struct aout_data_struct *aout_data;
 147 .      struct artdata *aout_ar_data;
 148 .      struct _oasys_data *oasys_obj_data;
 149 .      struct _oasys_ar_data *oasys_ar_data;
 150 .      struct coff_tdata *coff_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 elf_obj_tdata_struct *elf_obj_data;
 155 .      struct elf_core_tdata_struct *elf_core_data;
 156 .      struct bout_data_struct *bout_data;
 157 .      struct sun_core_struct *sun_core_data;
 158 .      PTR any;
 159 .      } tdata;
 160 .
 161 .    {* Used by the application to hold private data*}
 162 .    PTR usrdata;
 163 .
 164 .    {* Where all the allocated stuff under this BFD goes *}
 165 .    struct obstack memory;
 166 .
 167 .    asymbol **ld_symbols;
 168 .};
 169 .
 170 */
 171
 172 #include "bfd.h"
 173 #include "sysdep.h"
 174 #include "libbfd.h"
 175
 176 #undef strerror
 177 extern char *strerror();
 178
 179
 180 CONST short _bfd_host_big_endian = 0x0100;
 181         /* Accessing the above as (*(char*)&_bfd_host_big_endian), will
 182            return 1 if the host is big-endian, 0 otherwise.
 183            (assuming that a short is two bytes long!!!  FIXME)
 184            (See HOST_IS_BIG_ENDIAN_P in bfd.h.)  */
 185 \f
 186 /** Error handling
 187     o - Most functions return nonzero on success (check doc for
 188         precise semantics); 0 or NULL on error.
 189     o - Internal errors are documented by the value of bfd_error.
 190         If that is system_call_error then check errno.
 191     o - The easiest way to report this to the user is to use bfd_perror.
 192 */
 193
 194 bfd_ec bfd_error = no_error;
 195
 196 char *bfd_errmsgs[] = { "No error",
 197                         "System call error",
 198                         "Invalid target",
 199                         "File in wrong format",
 200                         "Invalid operation",
 201                         "Memory exhausted",
 202                         "No symbols",
 203                         "No relocation info",
 204                         "No more archived files",
 205                         "Malformed archive",
 206                         "Symbol not found",
 207                         "File format not recognized",
 208                         "File format is ambiguous",
 209                         "Section has no contents",
 210                         "Nonrepresentable section on output",
 211                         "Symbol needs debug section which does not exist",
 212                         "#<Invalid error code>"
 213                        };
 214
 215 static
 216 void
 217 DEFUN(bfd_nonrepresentable_section,(abfd, name),
 218          CONST  bfd * CONST abfd AND
 219          CONST  char * CONST name)
 220 {
 221   printf("bfd error writing file %s, format %s can't represent section %s\n",
 222          abfd->filename,
 223          abfd->xvec->name,
 224          name);
 225   exit(1);
 226 }
 227
 228 static
 229 void
 230 DEFUN(bfd_undefined_symbol,(relent, seclet),
 231       CONST  arelent *relent AND
 232       CONST  struct bfd_seclet_struct *seclet)
 233 {
 234   asymbol *symbol = *(relent->sym_ptr_ptr);
 235   printf("bfd error relocating, symbol %s is undefined\n",
 236          symbol->name);
 237   exit(1);
 238 }
 239 static
 240 void
 241 DEFUN(bfd_reloc_value_truncated,(relent, seclet),
 242          CONST  arelent *relent AND
 243       struct bfd_seclet_struct *seclet)
 244 {
 245   asymbol *symbol = *(relent->sym_ptr_ptr);
 246   printf("bfd error relocating, value truncated\n");
 247   exit(1);
 248 }
 249 static
 250 void
 251 DEFUN(bfd_reloc_is_dangerous,(relent, seclet),
 252       CONST  arelent *relent AND
 253      CONST  struct bfd_seclet_struct *seclet)
 254 {
 255   asymbol *symbol = *(relent->sym_ptr_ptr);
 256   printf("bfd error relocating, dangerous\n");
 257   exit(1);
 258 }
 259
 260 bfd_error_vector_type bfd_error_vector =
 261   {
 262   bfd_nonrepresentable_section ,
 263   bfd_undefined_symbol,
 264   bfd_reloc_value_truncated,
 265   bfd_reloc_is_dangerous,
 266   };
 267
 268
 269 char *
 270 bfd_errmsg (error_tag)
 271      bfd_ec error_tag;
 272 {
 273 #ifndef errno
 274   extern int errno;
 275 #endif
 276   if (error_tag == system_call_error)
 277     return strerror (errno);
 278
 279   if ((((int)error_tag <(int) no_error) ||
 280        ((int)error_tag > (int)invalid_error_code)))
 281     error_tag = invalid_error_code;/* sanity check */
 282
 283   return bfd_errmsgs [(int)error_tag];
 284 }
 285
 286
 287 void bfd_default_error_trap(error_tag)
 288 bfd_ec error_tag;
 289 {
 290   printf("bfd assert fail (%s)\n", bfd_errmsg(error_tag));
 291 }
 292
 293 void (*bfd_error_trap)() = bfd_default_error_trap;
 294 void (*bfd_error_nonrepresentabltrap)() = bfd_default_error_trap;
 295
 296 void
 297 DEFUN(bfd_perror,(message),
 298       CONST char *message)
 299 {
 300   if (bfd_error == system_call_error)
 301     perror((char *)message);            /* must be system error then... */
 302   else {
 303     if (message == NULL || *message == '\0')
 304       fprintf (stderr, "%s\n", bfd_errmsg (bfd_error));
 305     else
 306       fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_error));
 307   }
 308 }
 309
 310  \f
 311 /** Symbols */
 312
 313
 314 /*
 315 FUNCTION
 316         bfd_get_reloc_upper_bound
 317
 318 SYNOPSIS
 319         unsigned int bfd_get_reloc_upper_bound(bfd *abfd, asection *sect);
 320
 321 DESCRIPTION
 322         This function return the number of bytes required to store the
 323         relocation information associated with section <<sect>>
 324         attached to bfd <<abfd>>
 325
 326 */
 327
 328
 329 unsigned int
 330 DEFUN(bfd_get_reloc_upper_bound,(abfd, asect),
 331      bfd *abfd AND
 332      sec_ptr asect)
 333 {
 334   if (abfd->format != bfd_object) {
 335     bfd_error = invalid_operation;
 336     return 0;
 337   }
 338
 339   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 340 }
 341
 342 /*
 343 FUNCTION
 344         bfd_canonicalize_reloc
 345
 346 SYNOPSIS
 347         unsigned int bfd_canonicalize_reloc
 348                 (bfd *abfd,
 349                 asection *sec,
 350                 arelent **loc,
 351                 asymbol **syms);
 352
 353 DESCRIPTION
 354         This function calls the back end associated with the open
 355         <<abfd>> and translates the external form of the relocation
 356         information attached to <<sec>> into the internal canonical
 357         form.  The table is placed into memory at <<loc>>, which has
 358         been preallocated, usually by a call to
 359         <<bfd_get_reloc_upper_bound>>.
 360
 361         The <<syms>> table is also needed for horrible internal magic
 362         reasons.
 363
 364
 365 */
 366 unsigned int
 367 DEFUN(bfd_canonicalize_reloc,(abfd, asect, location, symbols),
 368      bfd *abfd AND
 369      sec_ptr asect AND
 370      arelent **location AND
 371      asymbol **symbols)
 372 {
 373     if (abfd->format != bfd_object) {
 374             bfd_error = invalid_operation;
 375             return 0;
 376         }
 377     return BFD_SEND (abfd, _bfd_canonicalize_reloc,
 378                      (abfd, asect, location, symbols));
 379 }
 380
 381
 382 /*
 383 FUNCTION
 384         bfd_set_file_flags
 385
 386 SYNOPSIS
 387         boolean bfd_set_file_flags(bfd *abfd, flagword flags);
 388
 389 DESCRIPTION
 390         This function attempts to set the flag word in the referenced
 391         BFD structure to the value supplied.
 392
 393         Possible errors are:
 394         o wrong_format - The target bfd was not of object format.
 395         o invalid_operation - The target bfd was open for reading.
 396         o invalid_operation -
 397         The flag word contained a bit which was not applicable to the
 398         type of file. eg, an attempt was made to set the D_PAGED bit
 399         on a bfd format which does not support demand paging
 400
 401 */
 402
 403 boolean
 404 bfd_set_file_flags (abfd, flags)
 405      bfd *abfd;
 406      flagword flags;
 407 {
 408   if (abfd->format != bfd_object) {
 409     bfd_error = wrong_format;
 410     return false;
 411   }
 412
 413   if (bfd_read_p (abfd)) {
 414     bfd_error = invalid_operation;
 415     return false;
 416   }
 417
 418   if ((flags & bfd_applicable_file_flags (abfd)) != flags) {
 419     bfd_error = invalid_operation;
 420     return false;
 421   }
 422
 423   bfd_get_file_flags (abfd) = flags;
 424 return true;
 425 }
 426
 427 /*
 428 FUNCTION
 429         bfd_set_reloc
 430
 431 SYNOPSIS
 432         void bfd_set_reloc
 433           (bfd *abfd, asection *sec, arelent **rel, unsigned int count)
 434
 435 DESCRIPTION
 436         This function sets the relocation pointer and count within a
 437         section to the supplied values.
 438
 439 */
 440
 441 void
 442 bfd_set_reloc (ignore_abfd, asect, location, count)
 443      bfd *ignore_abfd;
 444      sec_ptr asect;
 445      arelent **location;
 446      unsigned int count;
 447 {
 448   asect->orelocation  = location;
 449   asect->reloc_count = count;
 450 }
 451
 452 void
 453 bfd_assert(file, line)
 454 char *file;
 455 int line;
 456 {
 457   printf("bfd assertion fail %s:%d\n",file,line);
 458 }
 459
 460
 461 /*
 462 FUNCTION
 463         bfd_set_start_address
 464
 465 DESCRIPTION
 466         Marks the entry point of an output BFD.
 467
 468 RETURNS
 469         Returns <<true>> on success, <<false>> otherwise.
 470
 471 SYNOPSIS
 472         boolean bfd_set_start_address(bfd *, bfd_vma);
 473 */
 474
 475 boolean
 476 bfd_set_start_address(abfd, vma)
 477 bfd *abfd;
 478 bfd_vma vma;
 479 {
 480   abfd->start_address = vma;
 481   return true;
 482 }
 483
 484
 485 /*
 486 FUNCTION
 487         The bfd_get_mtime function
 488
 489 SYNOPSIS
 490         long bfd_get_mtime(bfd *);
 491
 492 DESCRIPTION
 493         Return file modification time (as read from file system, or
 494         from archive header for archive members).
 495
 496 */
 497
 498 long
 499 bfd_get_mtime (abfd)
 500      bfd *abfd;
 501 {
 502   FILE *fp;
 503   struct stat buf;
 504
 505   if (abfd->mtime_set)
 506     return abfd->mtime;
 507
 508   fp = bfd_cache_lookup (abfd);
 509   if (0 != fstat (fileno (fp), &buf))
 510     return 0;
 511
 512   abfd->mtime = buf.st_mtime;           /* Save value in case anyone wants it */
 513   return buf.st_mtime;
 514 }
 515
 516 /*
 517 FUNCTION
 518         stuff
 519
 520 DESCRIPTION
 521         stuff which should be documented
 522
 523 .#define bfd_sizeof_headers(abfd, reloc) \
 524 .     BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
 525 .
 526 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
 527 .     BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, sec, syms, off, file, func, line))
 528 .
 529 .#define bfd_debug_info_start(abfd) \
 530 .        BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
 531 .
 532 .#define bfd_debug_info_end(abfd) \
 533 .        BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
 534 .
 535 .#define bfd_debug_info_accumulate(abfd, section) \
 536 .        BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
 537 .
 538 .#define bfd_stat_arch_elt(abfd, stat) \
 539 .        BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
 540 .
 541 .#define bfd_coff_swap_aux_in(a,e,t,c,i) \
 542 .        BFD_SEND (a, _bfd_coff_swap_aux_in, (a,e,t,c,i))
 543 .
 544 .#define bfd_coff_swap_sym_in(a,e,i) \
 545 .        BFD_SEND (a, _bfd_coff_swap_sym_in, (a,e,i))
 546 .
 547 .#define bfd_coff_swap_lineno_in(a,e,i) \
 548 .        BFD_SEND ( a, _bfd_coff_swap_lineno_in, (a,e,i))
 549 .
 550 .#define bfd_set_arch_mach(abfd, arch, mach)\
 551 .        BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
 552 .
 553 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
 554 .        BFD_SEND (abfd, _bfd_coff_swap_reloc_out, (abfd, i, o))
 555 .
 556 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
 557 .        BFD_SEND (abfd, _bfd_coff_swap_lineno_out, (abfd, i, o))
 558 .
 559 .#define bfd_coff_swap_aux_out(abfd, i, t,c,o) \
 560 .        BFD_SEND (abfd, _bfd_coff_swap_aux_out, (abfd, i,t,c, o))
 561 .
 562 .#define bfd_coff_swap_sym_out(abfd, i,o) \
 563 .        BFD_SEND (abfd, _bfd_coff_swap_sym_out, (abfd, i, o))
 564 .
 565 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
 566 .        BFD_SEND (abfd, _bfd_coff_swap_scnhdr_out, (abfd, i, o))
 567 .
 568 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
 569 .        BFD_SEND (abfd, _bfd_coff_swap_filehdr_out, (abfd, i, o))
 570 .
 571 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
 572 .        BFD_SEND (abfd, _bfd_coff_swap_aouthdr_out, (abfd, i, o))
 573 .
 574 .#define bfd_get_relocated_section_contents(abfd, seclet) \
 575 .       BFD_SEND (abfd, _bfd_get_relocated_section_contents, (abfd, seclet))
 576 .
 577 .#define bfd_relax_section(abfd, section, symbols) \
 578 .       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, symbols))
 579
 580 */
 581
 582
 583
 584
 585
 586