X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fopncls.c;h=a609e7dbd86680d0badf847b029babc48ed748eb;hb=e98fe4f7b54cbdf29aef9287bbb1bea8801dd05a;hp=63e9c51daed6ea0a1c64708631f140007d175cc6;hpb=16423a4a99210a59fc20ea069a5305ccee9414a5;p=binutils-gdb.git diff --git a/bfd/opncls.c b/bfd/opncls.c index 63e9c51daed..a609e7dbd86 100644 --- a/bfd/opncls.c +++ b/bfd/opncls.c @@ -1,125 +1,160 @@ -/* Copyright (C) 1990, 1991 Free Software Foundation, Inc. +/* opncls.c -- open and close a BFD. + Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 1997 + Free Software Foundation, Inc. -This file is part of BFD, the Binary File Diddler. + Written by Cygnus Support. -BFD is free software; you can redistribute it and/or modify +This file is part of BFD, the Binary File Descriptor library. + +This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 1, or (at your option) -any later version. +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. -BFD is distributed in the hope that it will be useful, +This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with BFD; see the file COPYING. If not, write to -the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ - -/* $Id$ */ - -/*** opncls.c -- open and close a bfd. */ +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#include "sysdep.h" #include "bfd.h" +#include "sysdep.h" +#include "objalloc.h" #include "libbfd.h" - -extern void bfd_cache_init(); -FILE *bfd_open_file(); +#ifndef S_IXUSR +#define S_IXUSR 0100 /* Execute by owner. */ +#endif +#ifndef S_IXGRP +#define S_IXGRP 0010 /* Execute by group. */ +#endif +#ifndef S_IXOTH +#define S_IXOTH 0001 /* Execute by others. */ +#endif /* fdopen is a loser -- we should use stdio exclusively. Unfortunately if we do that we can't use fcntl. */ - -/** Locking - - Locking is loosely controlled by the preprocessor variable - BFD_LOCKS. I say loosely because Unix barely understands locking - -- at least in BSD it doesn't affect programs which don't - explicitly use it! That is to say it's practically useless, though - if everyone uses this library you'll be OK. - - From among the many and varied lock facilities available, (none of - which, of course, knows about any other) we use the fcntl locks, - because they're Posix. - - The reason that bfd_openr and bfd_fdopenr exist, yet only bfd_openw - exists is because of locking. When we do output, we lock the - filename file for output, then open a temporary file which does not - actually get its correct filename until closing time. This is - safest, but requires the asymmetry in read and write entry points. - - Perhaps, since unix has so many different kinds of locking anyway, - we should use the emacs lock scheme?... */ - -bfd *new_bfd() +/* FIXME: This is no longer used. */ +long _bfd_chunksize = -1; + +/* Return a new BFD. All BFD's are allocated through this routine. */ + +bfd * +_bfd_new_bfd () { - bfd *nbfd = (bfd *)zalloc(sizeof(bfd)); + bfd *nbfd; + + nbfd = (bfd *) bfd_zmalloc (sizeof (bfd)); + if (nbfd == NULL) + return NULL; + + nbfd->memory = (PTR) objalloc_create (); + if (nbfd->memory == NULL) + { + bfd_set_error (bfd_error_no_memory); + return NULL; + } + + nbfd->arch_info = &bfd_default_arch_struct; nbfd->direction = no_direction; nbfd->iostream = NULL; nbfd->where = 0; - nbfd->sections = (asection *)NULL; + nbfd->sections = (asection *) NULL; nbfd->format = bfd_unknown; - nbfd->my_archive = (bfd *)NULL; - nbfd->origin = 0; + nbfd->my_archive = (bfd *) NULL; + nbfd->origin = 0; nbfd->opened_once = false; nbfd->output_has_begun = false; nbfd->section_count = 0; - nbfd->usrdata = (void *)NULL; - nbfd->sections = (asection *)NULL; + nbfd->usrdata = (PTR) NULL; nbfd->cacheable = false; - nbfd->flags = NO_FLAGS; + nbfd->flags = BFD_NO_FLAGS; + nbfd->mtime_set = false; + return nbfd; } -bfd *new_bfd_contained_in(obfd) -bfd *obfd; + +/* Allocate a new BFD as a member of archive OBFD. */ + +bfd * +_bfd_new_bfd_contained_in (obfd) + bfd *obfd; { - bfd *nbfd = new_bfd(obfd); - nbfd->xvec = obfd->xvec; - nbfd->my_archive = obfd; - nbfd->direction = read_direction; - return nbfd; + bfd *nbfd; + + nbfd = _bfd_new_bfd (); + nbfd->xvec = obfd->xvec; + nbfd->my_archive = obfd; + nbfd->direction = read_direction; + nbfd->target_defaulted = obfd->target_defaulted; + return nbfd; } -/** bfd_openr, bfd_fdopenr -- open for reading. - Returns a pointer to a freshly-allocated bfd on success, or NULL. */ +/* +SECTION + Opening and closing BFDs + +*/ + +/* +FUNCTION + bfd_openr + +SYNOPSIS + bfd *bfd_openr(CONST char *filename, CONST char *target); + +DESCRIPTION + Open the file @var{filename} (using <>) with the target + @var{target}. Return a pointer to the created BFD. + + Calls <>, so @var{target} is interpreted as by + that function. + + If <> is returned then an error has occured. Possible errors + are <>, <> or <> error. +*/ bfd * bfd_openr (filename, target) - char *filename; - char *target; + CONST char *filename; + CONST char *target; { bfd *nbfd; - bfd_target *target_vec; + const bfd_target *target_vec; - target_vec = bfd_find_target (target); - if (target_vec == NULL) { - bfd_error = invalid_target; + nbfd = _bfd_new_bfd (); + if (nbfd == NULL) return NULL; - } - bfd_error = system_call_error; - nbfd = new_bfd(); - if (nbfd == NULL) { - bfd_error = no_memory; - return NULL; - } + target_vec = bfd_find_target (target, nbfd); + if (target_vec == NULL) + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + bfd_set_error (bfd_error_invalid_target); + return NULL; + } nbfd->filename = filename; - nbfd->xvec = target_vec; - nbfd->direction = read_direction; + nbfd->direction = read_direction; + + if (bfd_open_file (nbfd) == NULL) + { + /* File didn't exist, or some such */ + bfd_set_error (bfd_error_system_call); + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } - if (bfd_open_file (nbfd) == NULL) { - bfd_error = system_call_error; /* File didn't exist, or some such */ - free (nbfd); - return NULL; - } return nbfd; } - /* Don't try to `optimize' this function: o - We lock using stack space so that interrupting the locking @@ -128,154 +163,496 @@ bfd_openr (filename, target) close it if anything goes wrong. Closing the stream means closing the file descriptor too, even though we didn't open it. */ +/* +FUNCTION + bfd_fdopenr + +SYNOPSIS + bfd *bfd_fdopenr(CONST char *filename, CONST char *target, int fd); + +DESCRIPTION + <> is to <> much like <> is to <>. + It opens a BFD on a file already described by the @var{fd} + supplied. + + When the file is later <>d, the file descriptor will be closed. + + If the caller desires that this file descriptor be cached by BFD + (opened as needed, closed as needed to free descriptors for + other opens), with the supplied @var{fd} used as an initial + file descriptor (but subject to closure at any time), call + bfd_set_cacheable(bfd, 1) on the returned BFD. The default is to + assume no cacheing; the file descriptor will remain open until + <>, and will not be affected by BFD operations on other + files. + + Possible errors are <>, <> and <>. +*/ bfd * bfd_fdopenr (filename, target, fd) - char *filename; - char *target; + CONST char *filename; + CONST char *target; int fd; { bfd *nbfd; - bfd_target *target_vec; + const bfd_target *target_vec; int fdflags; -#ifdef BFD_LOCKS - struct flock lock, *lockp = &lock; + + bfd_set_error (bfd_error_system_call); +#if ! defined(HAVE_FCNTL) || ! defined(F_GETFL) + fdflags = O_RDWR; /* Assume full access */ +#else + fdflags = fcntl (fd, F_GETFL, NULL); #endif + if (fdflags == -1) return NULL; - target_vec = bfd_find_target (target); - if (target_vec == NULL) { - bfd_error = invalid_target; + nbfd = _bfd_new_bfd (); + if (nbfd == NULL) return NULL; - } - bfd_error = system_call_error; - - fdflags = fcntl (fd, F_GETFL); - if (fdflags == -1) return NULL; - -#ifdef BFD_LOCKS - lockp->l_type = F_RDLCK; - if (fcntl (fd, F_SETLKW, lockp) == -1) return NULL; + target_vec = bfd_find_target (target, nbfd); + if (target_vec == NULL) + { + bfd_set_error (bfd_error_invalid_target); + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } + +#ifndef HAVE_FDOPEN + nbfd->iostream = (PTR) fopen (filename, FOPEN_RB); +#else + /* (O_ACCMODE) parens are to avoid Ultrix header file bug */ + switch (fdflags & (O_ACCMODE)) + { + case O_RDONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RB); break; + case O_WRONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB); break; + case O_RDWR: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB); break; + default: abort (); + } #endif - nbfd = new_bfd(); + if (nbfd->iostream == NULL) + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } - if (nbfd == NULL) { - bfd_error = no_memory; - return NULL; - } -#ifdef BFD_LOCKS - nbfd->lock = (struct flock *) (nbfd + 1); -#endif - /* if the fd were open for read only, this still would not hurt: */ - nbfd->iostream = (char *) fdopen (fd, "r+"); - if (nbfd->iostream == NULL) { - free (nbfd); - return NULL; - } - /* OK, put everything where it belongs */ nbfd->filename = filename; - nbfd->xvec = target_vec; /* As a special case we allow a FD open for read/write to be written through, although doing so requires that we end the previous clause with a preposition. */ - switch (fdflags & O_ACCMODE) { - case O_RDONLY: nbfd->direction = read_direction; break; - case O_WRONLY: nbfd->direction = write_direction; break; - case O_RDWR: nbfd->direction = both_direction; break; - default: abort (); - } - -#ifdef BFD_LOCKS - memcpy (nbfd->lock, lockp, sizeof (struct flock)) -#endif + /* (O_ACCMODE) parens are to avoid Ultrix header file bug */ + switch (fdflags & O_ACCMODE) + { + case O_RDONLY: nbfd->direction = read_direction; break; + case O_WRONLY: nbfd->direction = write_direction; break; + case O_RDWR: nbfd->direction = both_direction; break; + default: abort (); + } + + if (! bfd_cache_init (nbfd)) + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } + nbfd->opened_once = true; + + return nbfd; +} + +/* +FUNCTION + bfd_openstreamr - bfd_cache_init (nbfd); +SYNOPSIS + bfd *bfd_openstreamr(const char *, const char *, PTR); + +DESCRIPTION + + Open a BFD for read access on an existing stdio stream. When + the BFD is passed to <>, the stream will be closed. +*/ + +bfd * +bfd_openstreamr (filename, target, streamarg) + const char *filename; + const char *target; + PTR streamarg; +{ + FILE *stream = (FILE *) streamarg; + bfd *nbfd; + const bfd_target *target_vec; + + nbfd = _bfd_new_bfd (); + if (nbfd == NULL) + return NULL; + + target_vec = bfd_find_target (target, nbfd); + if (target_vec == NULL) + { + bfd_set_error (bfd_error_invalid_target); + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } + + nbfd->iostream = (PTR) stream; + nbfd->filename = filename; + nbfd->direction = read_direction; + + if (! bfd_cache_init (nbfd)) + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } return nbfd; } /** bfd_openw -- open for writing. - Returns a pointer to a freshly-allocated bfd on success, or NULL. + Returns a pointer to a freshly-allocated BFD on success, or NULL. See comment by bfd_fdopenr before you try to modify this function. */ +/* +FUNCTION + bfd_openw + +SYNOPSIS + bfd *bfd_openw(CONST char *filename, CONST char *target); + +DESCRIPTION + Create a BFD, associated with file @var{filename}, using the + file format @var{target}, and return a pointer to it. + + Possible errors are <>, <>, + <>. +*/ + bfd * bfd_openw (filename, target) - char *filename; - char *target; + CONST char *filename; + CONST char *target; { bfd *nbfd; - bfd_target *target_vec; - - target_vec = bfd_find_target (target); - if (target_vec == NULL) return NULL; + const bfd_target *target_vec; - bfd_error = system_call_error; + bfd_set_error (bfd_error_system_call); /* nbfd has to point to head of malloc'ed block so that bfd_close may reclaim it correctly. */ - nbfd = new_bfd(); - if (nbfd == NULL) { - bfd_error = no_memory; + nbfd = _bfd_new_bfd (); + if (nbfd == NULL) return NULL; - } + + target_vec = bfd_find_target (target, nbfd); + if (target_vec == NULL) + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } nbfd->filename = filename; - nbfd->xvec = target_vec; nbfd->direction = write_direction; - if (bfd_open_file (nbfd) == NULL) { - bfd_error = system_call_error; /* File not writeable, etc */ - free (nbfd); - return NULL; + if (bfd_open_file (nbfd) == NULL) + { + bfd_set_error (bfd_error_system_call); /* File not writeable, etc */ + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; } + return nbfd; } +/* + +FUNCTION + bfd_close + +SYNOPSIS + boolean bfd_close(bfd *abfd); + +DESCRIPTION + + Close a BFD. If the BFD was open for writing, + then pending operations are completed and the file written out + and closed. If the created file is executable, then + <> is called to mark it as such. + + All memory attached to the BFD is released. + + The file descriptor associated with the BFD is closed (even + if it was passed in to BFD by <>). + +RETURNS + <> is returned if all is ok, otherwise <>. +*/ + - -/** Close up shop, get your deposit back. */ boolean bfd_close (abfd) bfd *abfd; { - if (BFD_SEND (abfd, _close_and_cleanup, (abfd)) != true) return false; - - bfd_cache_close(abfd); -/* If the file was open for writing and is now executable - make it so */ - if (abfd->direction == write_direction - && abfd->flags & EXEC_P) { - struct stat buf; - stat(abfd->filename, &buf); - chmod(abfd->filename,buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH); - } + boolean ret; + + if (!bfd_read_p (abfd)) + { + if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) + return false; + } + + if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) + return false; + + ret = bfd_cache_close (abfd); + + /* If the file was open for writing and is now executable, + make it so */ + if (ret + && abfd->direction == write_direction + && abfd->flags & EXEC_P) + { + struct stat buf; + + if (stat (abfd->filename, &buf) == 0) + { + int mask = umask (0); + umask (mask); + chmod (abfd->filename, + (0777 + & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); + } + } + + objalloc_free ((struct objalloc *) abfd->memory); free (abfd); - return true; + + return ret; } -/* - called to create a bfd with no ascociated file or target - */ + +/* +FUNCTION + bfd_close_all_done + +SYNOPSIS + boolean bfd_close_all_done(bfd *); + +DESCRIPTION + Close a BFD. Differs from <> + since it does not complete any pending operations. This + routine would be used if the application had just used BFD for + swapping and didn't want to use any of the writing code. + + If the created file is executable, then <> is called + to mark it as such. + + All memory attached to the BFD is released. + +RETURNS + <> is returned if all is ok, otherwise <>. + +*/ + +boolean +bfd_close_all_done (abfd) + bfd *abfd; +{ + boolean ret; + + ret = bfd_cache_close (abfd); + + /* If the file was open for writing and is now executable, + make it so */ + if (ret + && abfd->direction == write_direction + && abfd->flags & EXEC_P) + { + struct stat buf; + + if (stat (abfd->filename, &buf) == 0) + { + int mask = umask (0); + umask (mask); + chmod (abfd->filename, + (0x777 + & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); + } + } + + objalloc_free ((struct objalloc *) abfd->memory); + free (abfd); + + return ret; +} + +/* +FUNCTION + bfd_create + +SYNOPSIS + bfd *bfd_create(CONST char *filename, bfd *templ); + +DESCRIPTION + Create a new BFD in the manner of + <>, but without opening a file. The new BFD + takes the target from the target used by @var{template}. The + format is always set to <>. + +*/ + bfd * -bfd_create(filename, template) -char *filename; -bfd *template; +bfd_create (filename, templ) + CONST char *filename; + bfd *templ; { - bfd *nbfd = new_bfd(); - if (nbfd == (bfd *)NULL) { - bfd_error = no_memory; - return (bfd *)NULL; - } + bfd *nbfd; + + nbfd = _bfd_new_bfd (); + if (nbfd == NULL) + return NULL; nbfd->filename = filename; - nbfd->xvec = template->xvec; + if (templ) + nbfd->xvec = templ->xvec; nbfd->direction = no_direction; + bfd_set_format (nbfd, bfd_object); return nbfd; +} + +/* +FUNCTION + bfd_make_writable +SYNOPSIS + boolean bfd_make_writable(bfd *abfd); +DESCRIPTION + Takes a BFD as created by <> and converts it + into one like as returned by <>. It does this + by converting the BFD to BFD_IN_MEMORY. It's assumed that + you will call <> on this bfd later. +RETURNS + <> is returned if all is ok, otherwise <>. +*/ + +boolean +bfd_make_writable(abfd) + bfd *abfd; +{ + struct bfd_in_memory *bim; + + if (abfd->direction != no_direction) + { + bfd_set_error (bfd_error_invalid_operation); + return false; + } + + bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory)); + abfd->iostream = (PTR) bim; + /* bfd_write will grow these as needed */ + bim->size = 0; + bim->buffer = 0; + + abfd->flags |= BFD_IN_MEMORY; + abfd->direction = write_direction; + abfd->where = 0; + + return true; +} + +/* +FUNCTION + bfd_make_readable + +SYNOPSIS + boolean bfd_make_readable(bfd *abfd); + +DESCRIPTION + Takes a BFD as created by <> and + <> and converts it into one like as + returned by <>. It does this by writing the + contents out to the memory buffer, then reversing the + direction. + +RETURNS + <> is returned if all is ok, otherwise <>. */ + +boolean +bfd_make_readable(abfd) + bfd *abfd; +{ + if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY)) + { + bfd_set_error (bfd_error_invalid_operation); + return false; + } + + if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) + return false; + + abfd->where = 0; + abfd->direction = read_direction; + + return true; +} + +/* +INTERNAL_FUNCTION + bfd_alloc + +SYNOPSIS + PTR bfd_alloc (bfd *abfd, size_t wanted); + +DESCRIPTION + Allocate a block of @var{wanted} bytes of memory attached to + <> and return a pointer to it. +*/ + + +PTR +bfd_alloc (abfd, size) + bfd *abfd; + size_t size; +{ + PTR ret; + + ret = objalloc_alloc (abfd->memory, (unsigned long) size); + if (ret == NULL) + bfd_set_error (bfd_error_no_memory); + return ret; +} + +PTR +bfd_zalloc (abfd, size) + bfd *abfd; + size_t size; +{ + PTR res; + + res = bfd_alloc (abfd, size); + if (res) + memset (res, 0, size); + return res; +} + +/* Free a block allocated for a BFD. */ + +void +bfd_release (abfd, block) + bfd *abfd; + PTR block; +{ + objalloc_free_block ((struct objalloc *) abfd->memory, block); }