X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fopncls.c;h=a609e7dbd86680d0badf847b029babc48ed748eb;hb=e98fe4f7b54cbdf29aef9287bbb1bea8801dd05a;hp=f3872bf31d47a1940d92ee25a383c36c78cf9c85;hpb=b7577823b60110d3b33ac7753e68a0291f0b132a;p=binutils-gdb.git diff --git a/bfd/opncls.c b/bfd/opncls.c index f3872bf31d4..a609e7dbd86 100644 --- a/bfd/opncls.c +++ b/bfd/opncls.c @@ -1,5 +1,7 @@ /* opncls.c -- open and close a BFD. - Copyright (C) 1990 91, 92, 93, 94, 1995 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. @@ -20,8 +22,8 @@ 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" #ifndef S_IXUSR #define S_IXUSR 0100 /* Execute by owner. */ @@ -36,9 +38,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* fdopen is a loser -- we should use stdio exclusively. Unfortunately if we do that we can't use fcntl. */ - -#define obstack_chunk_alloc malloc -#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. */ @@ -47,18 +48,15 @@ _bfd_new_bfd () { bfd *nbfd; - nbfd = (bfd *)bfd_zmalloc (sizeof (bfd)); - if (!nbfd) - { - bfd_set_error (bfd_error_no_memory); - return 0; - } + nbfd = (bfd *) bfd_zmalloc (sizeof (bfd)); + if (nbfd == NULL) + return NULL; - bfd_check_init(); - if (!obstack_begin(&nbfd->memory, 128)) + nbfd->memory = (PTR) objalloc_create (); + if (nbfd->memory == NULL) { bfd_set_error (bfd_error_no_memory); - return 0; + return NULL; } nbfd->arch_info = &bfd_default_arch_struct; @@ -66,16 +64,16 @@ _bfd_new_bfd () 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; @@ -89,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; @@ -129,30 +127,34 @@ bfd_openr (filename, target) bfd *nbfd; const bfd_target *target_vec; - nbfd = _bfd_new_bfd(); - if (nbfd == NULL) { - bfd_set_error (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_set_error (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_set_error (bfd_error_system_call); /* 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 @@ -198,7 +200,6 @@ bfd_fdopenr (filename, target, fd) int fdflags; bfd_set_error (bfd_error_system_call); - #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL) fdflags = O_RDWR; /* Assume full access */ #else @@ -206,33 +207,38 @@ bfd_fdopenr (filename, target, fd) #endif if (fdflags == -1) return NULL; - nbfd = _bfd_new_bfd(); - - if (nbfd == NULL) { - bfd_set_error (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_set_error (bfd_error_invalid_target); - return NULL; - } -#if defined(VMS) || defined(__GO32__) || defined (WIN32) - 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 */ @@ -242,15 +248,21 @@ 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)) - return NULL; + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } + nbfd->opened_once = true; return nbfd; } @@ -260,7 +272,7 @@ FUNCTION bfd_openstreamr SYNOPSIS - bfd *bfd_openstreamr(); + bfd *bfd_openstreamr(const char *, const char *, PTR); DESCRIPTION @@ -269,34 +281,38 @@ DESCRIPTION */ bfd * -bfd_openstreamr (filename, target, stream) +bfd_openstreamr (filename, target, streamarg) const char *filename; const char *target; - FILE *stream; + PTR streamarg; { + FILE *stream = (FILE *) streamarg; bfd *nbfd; const bfd_target *target_vec; nbfd = _bfd_new_bfd (); if (nbfd == NULL) - { - bfd_set_error (bfd_error_no_memory); - return 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 = (char *) stream; + nbfd->iostream = (PTR) stream; nbfd->filename = filename; nbfd->direction = read_direction; if (! bfd_cache_init (nbfd)) - return NULL; + { + objalloc_free ((struct objalloc *) nbfd->memory); + free (nbfd); + return NULL; + } return nbfd; } @@ -334,23 +350,29 @@ bfd_openw (filename, target) /* 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_set_error (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_set_error (bfd_error_system_call); /* 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; } @@ -369,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 <>). @@ -414,8 +436,8 @@ bfd_close (abfd) } } - (void) obstack_free (&abfd->memory, (PTR)0); - (void) free (abfd); + objalloc_free ((struct objalloc *) abfd->memory); + free (abfd); return ret; } @@ -436,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 <>. @@ -468,39 +490,13 @@ bfd_close_all_done (abfd) & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); } } - (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}. - -*/ + objalloc_free ((struct objalloc *) abfd->memory); + free (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; + return ret; } - - /* FUNCTION bfd_create @@ -521,63 +517,121 @@ bfd_create (filename, templ) CONST char *filename; bfd *templ; { - bfd *nbfd = _bfd_new_bfd(); - if (nbfd == (bfd *)NULL) { - bfd_set_error (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; { - return obstack_alloc(&(abfd->memory), size); -} + 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 @@ -586,8 +640,19 @@ bfd_zalloc (abfd, size) size_t size; { PTR res; - res = bfd_alloc(abfd, size); + + res = bfd_alloc (abfd, size); if (res) - memset(res, 0, (size_t)size); + 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); +}