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 /*proto*
  24 @section @code{typedef bfd}
  25
  26 A BFD is has type @code{bfd}; objects of this type are the cornerstone
  27 of any application using @code{libbfd}. References though the BFD and
  28 to data in the BFD give the entire BFD functionality.
  29
  30 Here is the struct used to define the type @code{bfd}.  This contains
  31 the major data about the file, and contains pointers to the rest of
  32 the data.
  33
  34 *+++
  35
  36 $struct _bfd
  37 ${
  38   The filename the application opened the BFD with.
  39
  40 $  CONST char *filename;
  41
  42 A pointer to the target jump table.
  43
  44 $  struct bfd_target *xvec;
  45
  46
  47 To avoid dragging too many header files into every file that
  48 includes @file{bfd.h}, IOSTREAM has been declared as a "char *", and MTIME
  49 as a "long".  Their correct types, to which they are cast when used,
  50 are "FILE *" and "time_t".
  51
  52 The iostream is the result of an fopen on the filename.
  53
  54 $  char *iostream;
  55
  56 Is the file being cached @xref{File Caching}.
  57
  58 $  boolean cacheable;
  59
  60 Marks whether there was a default target specified when the BFD was
  61 opened. This is used to select what matching algorithm to use to chose
  62 the back end.
  63
  64 $  boolean target_defaulted;
  65
  66 The caching routines use these to maintain a least-recently-used list of
  67 BFDs (@pxref{File Caching}).
  68
  69 $  struct _bfd *lru_prev, *lru_next;
  70
  71 When a file is closed by the caching routines, BFD retains state
  72 information on the file here:
  73
  74 $  file_ptr where;
  75
  76 and here:
  77
  78 $  boolean opened_once;
  79
  80 $  boolean mtime_set;
  81 File modified time
  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 anything. I
 105 believe that this can become always an add of origin, with origin set
 106 to 0 for non archive files.
 107
 108 $  file_ptr origin;
 109
 110 Remember when output has begun, to stop strange things happening.
 111
 112 $  boolean output_has_begun;
 113
 114 Pointer to linked list of sections
 115
 116 $  struct sec  *sections;
 117
 118 The number of sections
 119
 120 $  unsigned int section_count;
 121
 122 Stuff only useful for object files:
 123 The start address.
 124
 125 $  bfd_vma start_address;
 126 Used for input and output
 127
 128 $  unsigned int symcount;
 129 Symbol table for output BFD
 130
 131 $  struct symbol_cache_entry  **outsymbols;
 132
 133 Pointer to structure which contains architecture information
 134
 135 $  struct bfd_arch_info *arch_info;
 136
 137 Stuff only useful for archives:
 138
 139 $  PTR arelt_data;
 140 $  struct _bfd *my_archive;
 141 $  struct _bfd *next;
 142 $  struct _bfd *archive_head;
 143 $  boolean has_armap;
 144
 145 Used by the back end to hold private data.
 146
 147 $  PTR tdata;
 148
 149 Used by the application to hold private data
 150
 151 $  PTR usrdata;
 152
 153 Where all the allocated stuff under this BFD goes (@pxref{Memory Usage}).
 154
 155 $  struct obstack memory;
 156 $};
 157
 158 *---
 159
 160 */
 161 #include "bfd.h"
 162 #include "sysdep.h"
 163 #include "libbfd.h"
 164
 165 extern char *strerror();
 166
 167
 168 short _bfd_host_big_endian = 0x0100;
 169         /* Accessing the above as (*(char*)&_bfd_host_big_endian), will
 170            return 1 if the host is big-endian, 0 otherwise.
 171            (assuming that a short is two bytes long!!!  FIXME)
 172            (See HOST_IS_BIG_ENDIAN_P in bfd.h.)  */
 173 \f
 174 /** Error handling
 175     o - Most functions return nonzero on success (check doc for
 176         precise semantics); 0 or NULL on error.
 177     o - Internal errors are documented by the value of bfd_error.
 178         If that is system_call_error then check errno.
 179     o - The easiest way to report this to the user is to use bfd_perror.
 180 */
 181
 182 bfd_ec bfd_error = no_error;
 183
 184 char *bfd_errmsgs[] = { "No error",
 185                         "System call error",
 186                         "Invalid target",
 187                         "File in wrong format",
 188                         "Invalid operation",
 189                         "Memory exhausted",
 190                         "No symbols",
 191                         "No relocation info",
 192                         "No more archived files",
 193                         "Malformed archive",
 194                         "Symbol not found",
 195                         "File format not recognized",
 196                         "File format is ambiguous",
 197                         "Section has no contents",
 198                         "Nonrepresentable section on output",
 199                         "#<Invalid error code>"
 200                        };
 201
 202 static
 203 void
 204 DEFUN(bfd_nonrepresentable_section,(abfd, name),
 205          CONST  bfd * CONST abfd AND
 206          CONST  char * CONST name)
 207 {
 208   printf("bfd error writing file %s, format %s can't represent section %s\n",
 209          abfd->filename,
 210          abfd->xvec->name,
 211          name);
 212   exit(1);
 213 }
 214
 215 bfd_error_vector_type bfd_error_vector =
 216   {
 217   bfd_nonrepresentable_section
 218   };
 219
 220 char *
 221 bfd_errmsg (error_tag)
 222      bfd_ec error_tag;
 223 {
 224 #ifndef errno
 225   extern int errno;
 226 #endif
 227   if (error_tag == system_call_error)
 228     return strerror (errno);
 229
 230   if ((((int)error_tag <(int) no_error) ||
 231        ((int)error_tag > (int)invalid_error_code)))
 232     error_tag = invalid_error_code;/* sanity check */
 233
 234   return bfd_errmsgs [(int)error_tag];
 235 }
 236
 237
 238 void bfd_default_error_trap(error_tag)
 239 bfd_ec error_tag;
 240 {
 241   printf("bfd assert fail (%s)\n", bfd_errmsg(error_tag));
 242 }
 243
 244 void (*bfd_error_trap)() = bfd_default_error_trap;
 245 void (*bfd_error_nonrepresentabltrap)() = bfd_default_error_trap;
 246
 247 void
 248 DEFUN(bfd_perror,(message),
 249       CONST char *message)
 250 {
 251   if (bfd_error == system_call_error)
 252     perror((char *)message);            /* must be system error then... */
 253   else {
 254     if (message == NULL || *message == '\0')
 255       fprintf (stderr, "%s\n", bfd_errmsg (bfd_error));
 256     else
 257       fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_error));
 258   }
 259 }
 260
 261  \f
 262 /** Symbols */
 263
 264 /* returns the number of octets of storage required */
 265
 266 unsigned int
 267 get_reloc_upper_bound (abfd, asect)
 268      bfd *abfd;
 269      sec_ptr asect;
 270 {
 271   if (abfd->format != bfd_object) {
 272     bfd_error = invalid_operation;
 273     return 0;
 274   }
 275
 276   return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect));
 277 }
 278
 279 unsigned int
 280 bfd_canonicalize_reloc (abfd, asect, location, symbols)
 281      bfd *abfd;
 282      sec_ptr asect;
 283      arelent **location;
 284      asymbol **symbols;
 285 {
 286   if (abfd->format != bfd_object) {
 287     bfd_error = invalid_operation;
 288     return 0;
 289   }
 290
 291   return BFD_SEND (abfd, _bfd_canonicalize_reloc, (abfd, asect, location, symbols));
 292 }
 293
 294
 295 boolean
 296 bfd_set_file_flags (abfd, flags)
 297      bfd *abfd;
 298      flagword flags;
 299 {
 300   if (abfd->format != bfd_object) {
 301     bfd_error = wrong_format;
 302     return false;
 303   }
 304
 305   if (bfd_read_p (abfd)) {
 306     bfd_error = invalid_operation;
 307     return false;
 308   }
 309
 310   if ((flags & bfd_applicable_file_flags (abfd)) != flags) {
 311     bfd_error = invalid_operation;
 312     return false;
 313   }
 314
 315   bfd_get_file_flags (abfd) = flags;
 316 return true;
 317 }
 318
 319
 320 void
 321 bfd_set_reloc (ignore_abfd, asect, location, count)
 322      bfd *ignore_abfd;
 323      sec_ptr asect;
 324      arelent **location;
 325      unsigned int count;
 326 {
 327   asect->orelocation  = location;
 328   asect->reloc_count = count;
 329 }
 330
 331 void
 332 bfd_assert(file, line)
 333 char *file;
 334 int line;
 335 {
 336   printf("bfd assertion fail %s:%d\n",file,line);
 337 }
 338
 339
 340 /*proto* bfd_set_start_address
 341
 342 Marks the entry point of an output BFD. Returns @code{true} on
 343 success, @code{false} otherwise.
 344
 345 *; PROTO(boolean, bfd_set_start_address,(bfd *, bfd_vma));
 346 */
 347
 348 boolean
 349 bfd_set_start_address(abfd, vma)
 350 bfd *abfd;
 351 bfd_vma vma;
 352 {
 353   abfd->start_address = vma;
 354   return true;
 355 }
 356
 357
 358 /*proto*  bfd_get_mtime
 359
 360 Return cached file modification time (e.g. as read from archive header
 361 for archive members, or from file system if we have been called
 362 before); else determine modify time, cache it, and return it.
 363
 364 *; PROTO(long, bfd_get_mtime, (bfd *));
 365
 366 */
 367
 368 long
 369 bfd_get_mtime (abfd)
 370      bfd *abfd;
 371 {
 372   FILE *fp;
 373   struct stat buf;
 374
 375   if (abfd->mtime_set)
 376     return abfd->mtime;
 377
 378   fp = bfd_cache_lookup (abfd);
 379   if (0 != fstat (fileno (fp), &buf))
 380     return 0;
 381
 382   abfd->mtime_set = true;
 383   abfd->mtime = buf.st_mtime;
 384   return abfd->mtime;
 385 }
 386
 387 /*proto* stuff
 388
 389 *+
 390
 391 #define bfd_sizeof_headers(abfd, reloc) \
 392      BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
 393
 394 #define bfd_find_nearest_line(abfd, section, symbols, offset, filename_ptr, func, line_ptr) \
 395      BFD_SEND (abfd, _bfd_find_nearest_line,  (abfd, section, symbols, offset, filename_ptr, func, line_ptr))
 396
 397 #define bfd_debug_info_start(abfd) \
 398         BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
 399
 400 #define bfd_debug_info_end(abfd) \
 401         BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
 402
 403 #define bfd_debug_info_accumulate(abfd, section) \
 404         BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
 405
 406 #define bfd_stat_arch_elt(abfd, stat) \
 407         BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
 408
 409 #define bfd_coff_swap_aux_in(a,e,t,c,i) \
 410         BFD_SEND (a, _bfd_coff_swap_aux_in, (a,e,t,c,i))
 411
 412 #define bfd_coff_swap_sym_in(a,e,i) \
 413         BFD_SEND (a, _bfd_coff_swap_sym_in, (a,e,i))
 414
 415 #define bfd_coff_swap_lineno_in(a,e,i) \
 416         BFD_SEND ( a, _bfd_coff_swap_lineno_in, (a,e,i))
 417
 418 #define bfd_set_arch_mach(abfd, arch, mach)\
 419         BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
 420
 421 *-
 422
 423 */
 424
 425
 426
 427
 428
 429