X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fopncls.c;h=a609e7dbd86680d0badf847b029babc48ed748eb;hb=e98fe4f7b54cbdf29aef9287bbb1bea8801dd05a;hp=5c958c853d2a3476d78e308bb8878a55de1e1f2d;hpb=751446f635031a1bbafe755255a2ea09fdf2d948;p=binutils-gdb.git diff --git a/bfd/opncls.c b/bfd/opncls.c index 5c958c853d2..a609e7dbd86 100644 --- a/bfd/opncls.c +++ b/bfd/opncls.c @@ -1,5 +1,7 @@ /* opncls.c -- open and close a BFD. - Copyright (C) 1990-1991 Free Software Foundation, Inc. + Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 1997 + Free Software Foundation, Inc. + Written by Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -16,21 +18,28 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "bfd.h" #include "sysdep.h" +#include "objalloc.h" #include "libbfd.h" -#include "obstack.h" -extern void bfd_cache_init PARAMS ((bfd *)); -FILE *bfd_open_file PARAMS ((bfd *)); + +#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. */ - -#define obstack_chunk_alloc bfd_xmalloc_by_size_t -#define obstack_chunk_free free +/* FIXME: This is no longer used. */ +long _bfd_chunksize = -1; /* Return a new BFD. All BFD's are allocated through this routine. */ @@ -39,28 +48,32 @@ _bfd_new_bfd () { bfd *nbfd; - nbfd = (bfd *)bfd_zmalloc (sizeof (bfd)); - if (!nbfd) - return 0; + nbfd = (bfd *) bfd_zmalloc (sizeof (bfd)); + if (nbfd == NULL) + return NULL; - bfd_check_init(); - obstack_begin(&nbfd->memory, 128); + 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->my_archive = (bfd *) NULL; nbfd->origin = 0; nbfd->opened_once = false; nbfd->output_has_begun = false; nbfd->section_count = 0; - nbfd->usrdata = (PTR)NULL; + nbfd->usrdata = (PTR) NULL; nbfd->cacheable = false; - nbfd->flags = NO_FLAGS; + nbfd->flags = BFD_NO_FLAGS; nbfd->mtime_set = false; return nbfd; @@ -74,7 +87,7 @@ _bfd_new_bfd_contained_in (obfd) { bfd *nbfd; - nbfd = _bfd_new_bfd(); + nbfd = _bfd_new_bfd (); nbfd->xvec = obfd->xvec; nbfd->my_archive = obfd; nbfd->direction = read_direction; @@ -103,7 +116,7 @@ DESCRIPTION that function. If <> is returned then an error has occured. Possible errors - are <>, <> or <> error. + are <>, <> or <> error. */ bfd * @@ -112,32 +125,36 @@ bfd_openr (filename, target) CONST char *target; { bfd *nbfd; - bfd_target *target_vec; + const bfd_target *target_vec; - nbfd = _bfd_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) { - bfd_error = invalid_target; - return NULL; - } + 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->direction = read_direction; - if (bfd_open_file (nbfd) == NULL) { - bfd_error = system_call_error; /* File didn't exist, or some such */ - bfd_release(nbfd,0); - return NULL; - } + 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; + } + return nbfd; } - /* Don't try to `optimize' this function: o - We lock using stack space so that interrupting the locking @@ -169,7 +186,7 @@ DESCRIPTION <>, and will not be affected by BFD operations on other files. - Possible errors are <>, <> and <>. + Possible errors are <>, <> and <>. */ bfd * @@ -179,45 +196,49 @@ bfd_fdopenr (filename, target, fd) int fd; { bfd *nbfd; - bfd_target *target_vec; + const bfd_target *target_vec; int fdflags; - bfd_error = system_call_error; - -#ifdef NO_FCNTL + 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; - nbfd = _bfd_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) { - bfd_error = invalid_target; - return NULL; - } -#if defined(VMS) || defined(__GO32__) - nbfd->iostream = (char *)fopen(filename, FOPEN_RB); + 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 = (char *) fdopen (fd, FOPEN_RB); break; - case O_WRONLY: nbfd->iostream = (char *) fdopen (fd, FOPEN_RUB); break; - case O_RDWR: nbfd->iostream = (char *) fdopen (fd, FOPEN_RUB); break; - default: abort (); - } + 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 - if (nbfd->iostream == NULL) { - (void) obstack_free (&nbfd->memory, (PTR)0); - return NULL; - } + + if (nbfd->iostream == NULL) + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } /* OK, put everything where it belongs */ @@ -227,14 +248,71 @@ bfd_fdopenr (filename, target, fd) be written through, although doing so requires that we end the previous clause with a preposition. */ /* (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 (); - } + 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 + +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; - bfd_cache_init (nbfd); + if (! bfd_cache_init (nbfd)) + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } return nbfd; } @@ -255,8 +333,8 @@ DESCRIPTION Create a BFD, associated with file @var{filename}, using the file format @var{target}, and return a pointer to it. - Possible errors are <>, <>, - <>. + Possible errors are <>, <>, + <>. */ bfd * @@ -265,30 +343,36 @@ bfd_openw (filename, target) CONST char *target; { bfd *nbfd; - bfd_target *target_vec; + 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 = _bfd_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) return NULL; + if (target_vec == NULL) + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } nbfd->filename = filename; nbfd->direction = write_direction; - if (bfd_open_file (nbfd) == NULL) { - bfd_error = system_call_error; /* File not writeable, etc */ - (void) obstack_free (&nbfd->memory, (PTR)0); - 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; } @@ -307,7 +391,7 @@ DESCRIPTION and closed. If the created file is executable, then <> is called to mark it as such. - All memory attached to the BFD's obstacks is released. + 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 <>). @@ -323,35 +407,38 @@ bfd_close (abfd) { boolean ret; - if (!bfd_read_p(abfd)) - if (BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)) != true) - return false; + if (!bfd_read_p (abfd)) + { + if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) + return false; + } - if (BFD_SEND (abfd, _close_and_cleanup, (abfd)) != true) return false; + if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) + return false; - ret = bfd_cache_close(abfd); + ret = bfd_cache_close (abfd); /* If the file was open for writing and is now executable, make it so */ - if (ret == true + if (ret && abfd->direction == write_direction - && abfd->flags & EXEC_P) { - struct stat buf; - stat(abfd->filename, &buf); -#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 + && 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); - chmod(abfd->filename, 0777 & (buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH)); - } - (void) obstack_free (&abfd->memory, (PTR)0); - (void) free(abfd); return ret; } @@ -371,7 +458,7 @@ DESCRIPTION If the created file is executable, then <> is called to mark it as such. - All memory attached to the BFD's obstacks is released. + All memory attached to the BFD is released. RETURNS <> is returned if all is ok, otherwise <>. @@ -384,60 +471,32 @@ bfd_close_all_done (abfd) { boolean ret; - ret = bfd_cache_close(abfd); + ret = bfd_cache_close (abfd); /* If the file was open for writing and is now executable, make it so */ - if (ret == true + if (ret && abfd->direction == write_direction - && abfd->flags & EXEC_P) { - struct stat buf; - stat(abfd->filename, &buf); -#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 + && 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); - chmod(abfd->filename, 0x777 &(buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH)); - } - (void) obstack_free (&abfd->memory, (PTR)0); - (void) free(abfd); return ret; } - -/* -FUNCTION - bfd_alloc_size - -SYNOPSIS - bfd_size_type bfd_alloc_size(bfd *abfd); - -DESCRIPTION - Return the number of bytes in the obstacks connected to @var{abfd}. - -*/ - -bfd_size_type -bfd_alloc_size (abfd) - bfd *abfd; -{ - struct _obstack_chunk *chunk = abfd->memory.chunk; - size_t size = 0; - while (chunk) { - size += chunk->limit - &(chunk->contents[0]); - chunk = chunk->prev; - } - return size; -} - - - /* FUNCTION bfd_create @@ -458,64 +517,121 @@ bfd_create (filename, templ) CONST char *filename; bfd *templ; { - bfd *nbfd = _bfd_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; - if(templ) { + if (templ) nbfd->xvec = templ->xvec; - } nbfd->direction = no_direction; - bfd_set_format(nbfd, bfd_object); + bfd_set_format (nbfd, bfd_object); return nbfd; } /* -INTERNAL_FUNCTION - bfd_alloc_by_size_t +FUNCTION + bfd_make_writable SYNOPSIS - PTR bfd_alloc_by_size_t(bfd *abfd, size_t wanted); + boolean bfd_make_writable(bfd *abfd); DESCRIPTION - Allocate a block of @var{wanted} bytes of memory in the obstack - attatched to <> and return a pointer to it. -*/ + 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 <>. +*/ -PTR -bfd_alloc_by_size_t (abfd, size) +boolean +bfd_make_writable(abfd) bfd *abfd; - size_t size; { - PTR res = obstack_alloc(&(abfd->memory), size); - return res; -} + struct bfd_in_memory *bim; -void -bfd_alloc_grow (abfd, ptr, size) - bfd *abfd; - PTR ptr; - size_t size; -{ - (void) obstack_grow(&(abfd->memory), ptr, size); + 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; } -PTR -bfd_alloc_finish (abfd) +/* +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; { - return obstack_finish(&(abfd->memory)); + 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; { - return bfd_alloc_by_size_t(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 @@ -524,18 +640,19 @@ bfd_zalloc (abfd, size) size_t size; { PTR res; - res = bfd_alloc(abfd, size); - memset(res, 0, (size_t)size); + + res = bfd_alloc (abfd, size); + if (res) + memset (res, 0, size); return res; } -PTR -bfd_realloc (abfd, old, size) +/* Free a block allocated for a BFD. */ + +void +bfd_release (abfd, block) bfd *abfd; - PTR old; - size_t size; + PTR block; { - PTR res = bfd_alloc(abfd, size); - memcpy(res, old, (size_t)size); - return res; + objalloc_free_block ((struct objalloc *) abfd->memory, block); }