bfd/opncls.c

   1 /* opncls.c -- open and close a BFD.
   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 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libbfd.h"
  26 #include "obstack.h"
  27 extern void bfd_cache_init();
  28 FILE *bfd_open_file();
  29
  30 /* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
  31    if we do that we can't use fcntl.  */
  32
  33
  34 #define obstack_chunk_alloc bfd_xmalloc
  35 #define obstack_chunk_free free
  36
  37 /* Return a new BFD.  All BFD's are allocated through this routine.  */
  38
  39 bfd *new_bfd()
  40 {
  41   bfd *nbfd;
  42
  43   nbfd = (bfd *)zalloc (sizeof (bfd));
  44   if (!nbfd)
  45     return 0;
  46
  47   bfd_check_init();
  48   obstack_begin((PTR)&nbfd->memory, 128);
  49
  50   nbfd->arch_info = &bfd_default_arch_struct;
  51
  52   nbfd->direction = no_direction;
  53   nbfd->iostream = NULL;
  54   nbfd->where = 0;
  55   nbfd->sections = (asection *)NULL;
  56   nbfd->format = bfd_unknown;
  57   nbfd->my_archive = (bfd *)NULL;
  58   nbfd->origin = 0;
  59   nbfd->opened_once = false;
  60   nbfd->output_has_begun = false;
  61   nbfd->section_count = 0;
  62   nbfd->usrdata = (PTR)NULL;
  63   nbfd->sections = (asection *)NULL;
  64   nbfd->cacheable = false;
  65   nbfd->flags = NO_FLAGS;
  66   nbfd->mtime_set = false;
  67
  68
  69   return nbfd;
  70 }
  71
  72 /* Allocate a new BFD as a member of archive OBFD.  */
  73
  74 bfd *new_bfd_contained_in(obfd)
  75 bfd *obfd;
  76 {
  77         bfd *nbfd = new_bfd();
  78         nbfd->xvec = obfd->xvec;
  79         nbfd->my_archive = obfd;
  80         nbfd->direction = read_direction;
  81         nbfd->target_defaulted = obfd->target_defaulted;
  82         return nbfd;
  83 }
  84
  85 /*
  86 SECTION
  87         Opening and Closing BFDs
  88
  89 */
  90
  91 /*
  92 FUNCTION
  93         bfd_openr
  94
  95 SYNOPSIS
  96         bfd *bfd_openr(CONST char *filename, CONST char*target);
  97
  98 DESCRIPTION
  99         This function opens the file supplied (using <<fopen>>) with the target
 100         supplied, it returns a pointer to the created BFD.
 101
 102         If NULL is returned then an error has occured. Possible errors
 103         are <<no_memory>>, <<invalid_target>> or <<system_call>> error.
 104 */
 105
 106 bfd *
 107 DEFUN(bfd_openr, (filename, target),
 108       CONST char *filename AND
 109       CONST char *target)
 110 {
 111   bfd *nbfd;
 112   bfd_target *target_vec;
 113
 114   nbfd = new_bfd();
 115   if (nbfd == NULL) {
 116     bfd_error = no_memory;
 117     return NULL;
 118   }
 119
 120   target_vec = bfd_find_target (target, nbfd);
 121   if (target_vec == NULL) {
 122     bfd_error = invalid_target;
 123     return NULL;
 124   }
 125
 126   nbfd->filename = filename;
 127   nbfd->direction = read_direction;
 128
 129   if (bfd_open_file (nbfd) == NULL) {
 130     bfd_error = system_call_error;      /* File didn't exist, or some such */
 131     bfd_release(nbfd,0);
 132     return NULL;
 133   }
 134   return nbfd;
 135 }
 136
 137
 138 /* Don't try to `optimize' this function:
 139
 140    o - We lock using stack space so that interrupting the locking
 141        won't cause a storage leak.
 142    o - We open the file stream last, since we don't want to have to
 143        close it if anything goes wrong.  Closing the stream means closing
 144        the file descriptor too, even though we didn't open it.
 145  */
 146 /*
 147 FUNCTION
 148          bfd_fdopenr
 149
 150 SYNOPSIS
 151          bfd *bfd_fdopenr(CONST char *filename, CONST char *target, int fd);
 152
 153 DESCRIPTION
 154          bfd_fdopenr is to bfd_fopenr much like  fdopen is to fopen.
 155          It opens a BFD on a file already described by the @var{fd}
 156          supplied.
 157
 158          Possible errors are no_memory, invalid_target and system_call
 159          error.
 160 */
 161
 162 bfd *
 163 DEFUN(bfd_fdopenr,(filename, target, fd),
 164       CONST char *filename AND
 165       CONST char *target AND
 166       int fd)
 167 {
 168   bfd *nbfd;
 169   bfd_target *target_vec;
 170   int fdflags;
 171
 172   bfd_error = system_call_error;
 173
 174 #ifdef NO_FCNTL
 175   fdflags = O_RDWR;                     /* Assume full access */
 176 #else
 177   fdflags = fcntl (fd, F_GETFL, NULL);
 178 #endif
 179   if (fdflags == -1) return NULL;
 180
 181   nbfd = new_bfd();
 182
 183   if (nbfd == NULL) {
 184     bfd_error = no_memory;
 185     return NULL;
 186   }
 187
 188   target_vec = bfd_find_target (target, nbfd);
 189   if (target_vec == NULL) {
 190     bfd_error = invalid_target;
 191     return NULL;
 192   }
 193
 194 #ifdef FASCIST_FDOPEN
 195   nbfd->iostream = (char *) fdopen (fd, FOPEN_RB);
 196 #else
 197   /* if the fd were open for read only, this still would not hurt: */
 198   nbfd->iostream = (char *) fdopen (fd, FOPEN_RUB);
 199 #endif
 200   if (nbfd->iostream == NULL) {
 201     (void) obstack_free (&nbfd->memory, (PTR)0);
 202     return NULL;
 203   }
 204
 205   /* OK, put everything where it belongs */
 206
 207   nbfd->filename = filename;
 208
 209   /* As a special case we allow a FD open for read/write to
 210      be written through, although doing so requires that we end
 211      the previous clause with a preposition.  */
 212   /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
 213   switch (fdflags & (O_ACCMODE)) {
 214   case O_RDONLY: nbfd->direction = read_direction; break;
 215   case O_WRONLY: nbfd->direction = write_direction; break;
 216   case O_RDWR: nbfd->direction = both_direction; break;
 217   default: abort ();
 218   }
 219
 220   bfd_cache_init (nbfd);
 221
 222   return nbfd;
 223 }
 224 \f
 225 /** bfd_openw -- open for writing.
 226   Returns a pointer to a freshly-allocated BFD on success, or NULL.
 227
 228   See comment by bfd_fdopenr before you try to modify this function. */
 229
 230 /*
 231 FUNCTION
 232         bfd_openw
 233
 234 SYNOPSIS
 235         bfd *bfd_openw(CONST char *filename, CONST char *target);
 236
 237 DESCRIPTION
 238         Creates a BFD, associated with file @var{filename}, using the
 239         file format @var{target}, and returns a pointer to it.
 240
 241         Possible errors are system_call_error, no_memory,
 242         invalid_target.
 243 */
 244
 245 bfd *
 246 DEFUN(bfd_openw,(filename, target),
 247       CONST char *filename AND
 248       CONST char *target)
 249 {
 250   bfd *nbfd;
 251   bfd_target *target_vec;
 252
 253   bfd_error = system_call_error;
 254
 255   /* nbfd has to point to head of malloc'ed block so that bfd_close may
 256      reclaim it correctly. */
 257
 258   nbfd = new_bfd();
 259   if (nbfd == NULL) {
 260     bfd_error = no_memory;
 261     return NULL;
 262   }
 263
 264   target_vec = bfd_find_target (target, nbfd);
 265   if (target_vec == NULL) return NULL;
 266
 267   nbfd->filename = filename;
 268   nbfd->direction = write_direction;
 269
 270   if (bfd_open_file (nbfd) == NULL) {
 271     bfd_error = system_call_error;      /* File not writeable, etc */
 272     (void) obstack_free (&nbfd->memory, (PTR)0);
 273     return NULL;
 274   }
 275   return nbfd;
 276 }
 277
 278 /*
 279
 280 FUNCTION
 281         bfd_close
 282
 283 SYNOPSIS
 284         boolean bfd_close(bfd *);
 285
 286 DESCRIPTION
 287
 288         This function closes a BFD. If the BFD was open for writing,
 289         then pending operations are completed and the file written out
 290         and closed. If the created file is executable, then
 291         <<chmod>> is called to mark it as such.
 292
 293         All memory attached to the BFD's obstacks is released.
 294
 295 RETURNS
 296         <<true>> is returned if all is ok, otherwise <<false>>.
 297 */
 298
 299
 300 boolean
 301 DEFUN(bfd_close,(abfd),
 302       bfd *abfd)
 303 {
 304   if (!bfd_read_p(abfd))
 305     if (BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)) != true)
 306       return false;
 307
 308   if (BFD_SEND (abfd, _close_and_cleanup, (abfd)) != true) return false;
 309
 310   bfd_cache_close(abfd);
 311
 312   /* If the file was open for writing and is now executable,
 313      make it so */
 314   if (abfd->direction == write_direction
 315       && abfd->flags & EXEC_P) {
 316     struct stat buf;
 317     stat(abfd->filename, &buf);
 318 #ifndef S_IXUSR
 319 #define S_IXUSR 0100    /* Execute by owner.  */
 320 #endif
 321 #ifndef S_IXGRP
 322 #define S_IXGRP 0010    /* Execute by group.  */
 323 #endif
 324 #ifndef S_IXOTH
 325 #define S_IXOTH 0001    /* Execute by others.  */
 326 #endif
 327
 328     chmod(abfd->filename, 0777  & (buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH));
 329   }
 330   (void) obstack_free (&abfd->memory, (PTR)0);
 331   (void) free(abfd);
 332   return true;
 333 }
 334
 335 /*
 336 FUNCTION
 337         bfd_close_all_done
 338
 339 SYNOPSIS
 340         boolean bfd_close_all_done(bfd *);
 341
 342 DESCRIPTION
 343         This function closes a BFD. It differs from <<bfd_close>>
 344         since it does not complete any pending operations.  This
 345         routine would be used if the application had just used BFD for
 346         swapping and didn't want to use any of the writing code.
 347
 348         If the created file is executable, then <<chmod>> is called
 349         to mark it as such.
 350
 351         All memory attached to the BFD's obstacks is released.
 352
 353 RETURNS
 354         <<true>> is returned if all is ok, otherwise <<false>>.
 355
 356 */
 357
 358 boolean
 359 DEFUN(bfd_close_all_done,(abfd),
 360       bfd *abfd)
 361 {
 362   bfd_cache_close(abfd);
 363
 364   /* If the file was open for writing and is now executable,
 365      make it so */
 366   if (abfd->direction == write_direction
 367       && abfd->flags & EXEC_P) {
 368     struct stat buf;
 369     stat(abfd->filename, &buf);
 370 #ifndef S_IXUSR
 371 #define S_IXUSR 0100    /* Execute by owner.  */
 372 #endif
 373 #ifndef S_IXGRP
 374 #define S_IXGRP 0010    /* Execute by group.  */
 375 #endif
 376 #ifndef S_IXOTH
 377 #define S_IXOTH 0001    /* Execute by others.  */
 378 #endif
 379
 380     chmod(abfd->filename, 0x777 &(buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH));
 381   }
 382   (void) obstack_free (&abfd->memory, (PTR)0);
 383   (void) free(abfd);
 384   return true;
 385 }
 386
 387
 388 /*
 389 FUNCTION
 390         bfd_alloc_size
 391
 392 SYNOPSIS
 393         bfd_size_type bfd_alloc_size(bfd *abfd);
 394
 395 DESCRIPTION
 396         Return the number of bytes in the obstacks connected to the
 397         supplied BFD.
 398
 399 */
 400
 401 bfd_size_type
 402 DEFUN(bfd_alloc_size,(abfd),
 403       bfd *abfd)
 404 {
 405   struct _obstack_chunk *chunk = abfd->memory.chunk;
 406   size_t size = 0;
 407   while (chunk) {
 408     size += chunk->limit - &(chunk->contents[0]);
 409     chunk = chunk->prev;
 410   }
 411   return size;
 412 }
 413
 414
 415
 416 /*
 417 FUNCTION
 418         bfd_create
 419
 420 SYNOPSIS
 421         bfd *bfd_create(CONST char *filename, bfd *template);
 422
 423 DESCRIPTION
 424         This routine creates a new BFD in the manner of
 425         <<bfd_openw>>, but without opening a file. The new BFD
 426         takes the target from the target used by @var{template}. The
 427         format is always set to <<bfd_object>>.
 428
 429 */
 430
 431 bfd *
 432 DEFUN(bfd_create,(filename, template),
 433       CONST char *filename AND
 434       bfd *template)
 435 {
 436   bfd *nbfd = new_bfd();
 437   if (nbfd == (bfd *)NULL) {
 438     bfd_error = no_memory;
 439     return (bfd *)NULL;
 440   }
 441   nbfd->filename = filename;
 442   if(template) {
 443     nbfd->xvec = template->xvec;
 444   }
 445   nbfd->direction = no_direction;
 446   bfd_set_format(nbfd, bfd_object);
 447   return nbfd;
 448 }
 449
 450 /*
 451 INTERNAL_FUNCTION
 452         bfd_alloc_by_size_t
 453
 454 SYNOPSIS
 455         PTR bfd_alloc_by_size_t(bfd *abfd, size_t wanted);
 456
 457 DESCRIPTION
 458         This function allocates a block of memory in the obstack
 459         attatched to <<abfd>> and returns a pointer to it.
 460 */
 461
 462
 463 PTR
 464 DEFUN(bfd_alloc_by_size_t,(abfd, size),
 465       bfd *abfd AND
 466       size_t size)
 467 {
 468   PTR res = obstack_alloc(&(abfd->memory), size);
 469   return res;
 470 }
 471
 472 DEFUN(void bfd_alloc_grow,(abfd, ptr, size),
 473       bfd *abfd AND
 474       PTR ptr AND
 475       bfd_size_type size)
 476 {
 477   (void)   obstack_grow(&(abfd->memory), ptr, size);
 478 }
 479 DEFUN(PTR bfd_alloc_finish,(abfd),
 480       bfd *abfd)
 481 {
 482   return obstack_finish(&(abfd->memory));
 483 }
 484
 485 DEFUN(PTR bfd_alloc, (abfd, size),
 486       bfd *abfd AND
 487       bfd_size_type size)
 488 {
 489   return bfd_alloc_by_size_t(abfd, (size_t)size);
 490 }
 491
 492 DEFUN(PTR bfd_zalloc,(abfd, size),
 493       bfd *abfd AND
 494       bfd_size_type size)
 495 {
 496   PTR res = bfd_alloc(abfd, size);
 497   memset(res, 0, (size_t)size);
 498   return res;
 499 }
 500
 501 DEFUN(PTR bfd_realloc,(abfd, old, size),
 502       bfd *abfd AND
 503       PTR old AND
 504       bfd_size_type size)
 505 {
 506   PTR res = bfd_alloc(abfd, size);
 507   memcpy(res, old, (size_t)size);
 508   return res;
 509 }
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519