X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fopncls.c;h=c24438820bd4f537bd2f7389e7fc4c60eed7ac21;hb=52b69c9e01afa3fffa5f9e83d7e560f47610d651;hp=63e9c51daed6ea0a1c64708631f140007d175cc6;hpb=4a81b56152631cda9dc351cb4d2f61f395ee4414;p=deliverable%2Fbinutils-gdb.git

diff --git a/bfd/opncls.c b/bfd/opncls.c
index 63e9c51dae..c24438820b 100644
--- a/bfd/opncls.c
+++ b/bfd/opncls.c
@@ -1,281 +1,701 @@
-/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+/* opncls.c -- open and close a BFD.
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
+   2001, 2002
+   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
-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.
+   This file is part of BFD, the Binary File Descriptor library.
 
-BFD 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.
+   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 2 of the License, or
+   (at your option) any later version.
 
-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.  */
+   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.
 
-/* $Id$ */
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
-/*** opncls.c -- open and close a bfd. */
-
-#include "sysdep.h"
 #include "bfd.h"
+#include "sysdep.h"
+#include "objalloc.h"
 #include "libbfd.h"
 
+#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
+
+/* Counter used to initialize the bfd identifier.  */
 
-extern void bfd_cache_init();
-FILE *bfd_open_file();
+static unsigned int _bfd_id_counter = 0;
 
 /* 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()
+/* 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 ((bfd_size_type) sizeof (bfd));
+  if (nbfd == NULL)
+    return NULL;
+
+  nbfd->id = _bfd_id_counter++;
+
+  nbfd->memory = (PTR) objalloc_create ();
+  if (nbfd->memory == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      free (nbfd);
+      return NULL;
+    }
+
+  nbfd->arch_info = &bfd_default_arch_struct;
 
   nbfd->direction = no_direction;
   nbfd->iostream = NULL;
   nbfd->where = 0;
-  nbfd->sections = (asection *)NULL;
+  if (!bfd_hash_table_init_n (&nbfd->section_htab,
+			      bfd_section_hash_newfunc,
+			      251))
+    {
+      free (nbfd);
+      return NULL;
+    }
+  nbfd->sections = (asection *) NULL;
+  nbfd->section_tail = &nbfd->sections;
   nbfd->format = bfd_unknown;
-  nbfd->my_archive = (bfd *)NULL;
-  nbfd->origin = 0;				   
-  nbfd->opened_once = false;
-  nbfd->output_has_begun = false;
+  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->cacheable = false;
-  nbfd->flags = NO_FLAGS;
+  nbfd->usrdata = (PTR) NULL;
+  nbfd->cacheable = FALSE;
+  nbfd->flags = BFD_NO_FLAGS;
+  nbfd->mtime_set = FALSE;
+
+  return nbfd;
+}
+
+/* Allocate a new BFD as a member of archive OBFD.  */
+
+bfd *
+_bfd_new_bfd_contained_in (obfd)
+     bfd *obfd;
+{
+  bfd *nbfd;
+
+  nbfd = _bfd_new_bfd ();
+  if (nbfd == NULL)
+    return NULL;
+  nbfd->xvec = obfd->xvec;
+  nbfd->my_archive = obfd;
+  nbfd->direction = read_direction;
+  nbfd->target_defaulted = obfd->target_defaulted;
   return nbfd;
 }
-bfd *new_bfd_contained_in(obfd)
-bfd *obfd;
+
+/* Delete a BFD.  */
+
+void
+_bfd_delete_bfd (abfd)
+     bfd *abfd;
 {
-	bfd *nbfd = new_bfd(obfd);
-	nbfd->xvec = obfd->xvec;
-	nbfd->my_archive = obfd;
-	nbfd->direction = read_direction;
-	return nbfd;
+  bfd_hash_table_free (&abfd->section_htab);
+  objalloc_free ((struct objalloc *) abfd->memory);
+  free (abfd);
 }
 
-/** 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 <<fopen>>) with the target
+	@var{target}.  Return a pointer to the created BFD.
+
+	Calls <<bfd_find_target>>, so @var{target} is interpreted as by
+	that function.
+
+	If <<NULL>> is returned then an error has occured.   Possible errors
+	are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
+	<<system_call>> 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)
+    {
+      _bfd_delete_bfd (nbfd);
+      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);
+      _bfd_delete_bfd (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
        won't cause a storage leak.
    o - We open the file stream last, since we don't want to have to
        close it if anything goes wrong.  Closing the stream means closing
-       the file descriptor too, even though we didn't open it.
- */
+       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
+	<<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
+	<<fopen>>.  It opens a BFD on a file already described by the
+	@var{fd} supplied.
+
+	When the file is later <<bfd_close>>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 <<bfd_close>>, and will not be affected by BFD operations
+	on other files.
+
+	Possible errors are <<bfd_error_no_memory>>,
+	<<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
+*/
 
 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;
-#endif
 
-  target_vec = bfd_find_target (target);
-  if (target_vec == NULL) {
-    bfd_error = invalid_target;
+  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;
-  }
 
-  bfd_error = system_call_error;
-  
-  fdflags = fcntl (fd, F_GETFL);
-  if (fdflags == -1) return NULL;
+  nbfd = _bfd_new_bfd ();
+  if (nbfd == NULL)
+    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_delete_bfd (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 == 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 */
+  if (nbfd->iostream == NULL)
+    {
+      _bfd_delete_bfd (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))
+    {
+      _bfd_delete_bfd (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 <<bfd_close>>, 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_delete_bfd (nbfd);
+      return NULL;
+    }
+
+  nbfd->iostream = (PTR) stream;
+  nbfd->filename = filename;
+  nbfd->direction = read_direction;
+
+  if (! bfd_cache_init (nbfd))
+    {
+      _bfd_delete_bfd (nbfd);
+      return NULL;
+    }
 
   return nbfd;
 }
 
-/** bfd_openw -- open for writing.
-  Returns a pointer to a freshly-allocated bfd on success, or NULL.
+/* bfd_openw -- open for writing.
+   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);
 
-  See comment by bfd_fdopenr before you try to modify this function. */
+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_error_system_call>>, <<bfd_error_no_memory>>,
+	<<bfd_error_invalid_target>>.
+*/
 
 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;
-
-  bfd_error = system_call_error;
+  const bfd_target *target_vec;
 
   /* 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;
+     reclaim it correctly.  */
+  nbfd = _bfd_new_bfd ();
+  if (nbfd == NULL)
     return NULL;
-  }
+
+  target_vec = bfd_find_target (target, nbfd);
+  if (target_vec == NULL)
+    {
+      _bfd_delete_bfd (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)
+    {
+      /* File not writeable, etc.  */
+      bfd_set_error (bfd_error_system_call);
+      _bfd_delete_bfd (nbfd);
+      return NULL;
   }
+
   return nbfd;
 }
 
+/*
 
-
-/** Close up shop, get your deposit back. */
-boolean
+FUNCTION
+	bfd_close
+
+SYNOPSIS
+	bfd_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 <<chmod>> 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 <<bfd_fdopenr>>).
+
+RETURNS
+	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
+*/
+
+
+bfd_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);
-  }
-  free (abfd);
-  return true;
+  bfd_boolean ret;
+
+  if (bfd_write_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)
+	{
+	  unsigned int mask = umask (0);
+
+	  umask (mask);
+	  chmod (abfd->filename,
+		 (0777
+		  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
+	}
+    }
+
+  _bfd_delete_bfd (abfd);
+
+  return ret;
 }
-/* 
- called to create a bfd with no ascociated file or target 
- */
+
+/*
+FUNCTION
+	bfd_close_all_done
+
+SYNOPSIS
+	bfd_boolean bfd_close_all_done (bfd *);
+
+DESCRIPTION
+	Close a BFD.  Differs from <<bfd_close>> 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 <<chmod>> is called
+	to mark it as such.
+
+	All memory attached to the BFD is released.
+
+RETURNS
+	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
+*/
+
+bfd_boolean
+bfd_close_all_done (abfd)
+     bfd *abfd;
+{
+  bfd_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)
+	{
+	  unsigned int mask = umask (0);
+
+	  umask (mask);
+	  chmod (abfd->filename,
+		 (0777
+		  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
+	}
+    }
+
+  _bfd_delete_bfd (abfd);
+
+  return ret;
+}
+
+/*
+FUNCTION
+	bfd_create
+
+SYNOPSIS
+	bfd *bfd_create(const char *filename, bfd *templ);
+
+DESCRIPTION
+	Create a new BFD in the manner of <<bfd_openw>>, 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_object>>.
+*/
+
 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
+	bfd_boolean bfd_make_writable (bfd *abfd);
 
+DESCRIPTION
+	Takes a BFD as created by <<bfd_create>> and converts it
+	into one like as returned by <<bfd_openw>>.  It does this
+	by converting the BFD to BFD_IN_MEMORY.  It's assumed that
+	you will call <<bfd_make_readable>> on this bfd later.
 
+RETURNS
+	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
+*/
+
+bfd_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 ((bfd_size_type) sizeof (struct bfd_in_memory)));
+  abfd->iostream = (PTR) bim;
+  /* bfd_bwrite 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
+	bfd_boolean bfd_make_readable (bfd *abfd);
+
+DESCRIPTION
+	Takes a BFD as created by <<bfd_create>> and
+	<<bfd_make_writable>> and converts it into one like as
+	returned by <<bfd_openr>>.  It does this by writing the
+	contents out to the memory buffer, then reversing the
+	direction.
+
+RETURNS
+	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
+
+bfd_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;
+
+  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
+    return FALSE;
+
+
+  abfd->arch_info = &bfd_default_arch_struct;
+
+  abfd->where = 0;
+  abfd->format = bfd_unknown;
+  abfd->my_archive = (bfd *) NULL;
+  abfd->origin = 0;
+  abfd->opened_once = FALSE;
+  abfd->output_has_begun = FALSE;
+  abfd->section_count = 0;
+  abfd->usrdata = (PTR) NULL;
+  abfd->cacheable = FALSE;
+  abfd->flags = BFD_IN_MEMORY;
+  abfd->mtime_set = FALSE;
+
+  abfd->target_defaulted = TRUE;
+  abfd->direction = read_direction;
+  abfd->sections = 0;
+  abfd->symcount = 0;
+  abfd->outsymbols = 0;
+  abfd->tdata.any = 0;
+
+  bfd_section_list_clear (abfd);
+  bfd_check_format (abfd, bfd_object);
+
+  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
+	<<abfd>> and return a pointer to it.
+*/
+
+
+PTR
+bfd_alloc (abfd, size)
+     bfd *abfd;
+     bfd_size_type size;
+{
+  PTR ret;
+
+  if (size != (unsigned long) size)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return NULL;
+    }
+
+  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;
+     bfd_size_type size;
+{
+  PTR res;
+
+  res = bfd_alloc (abfd, size);
+  if (res)
+    memset (res, 0, (size_t) size);
+  return res;
+}
+
+/* Free a block allocated for a BFD.
+   Note:  Also frees all more recently allocated blocks!  */
+
+void
+bfd_release (abfd, block)
+     bfd *abfd;
+     PTR block;
+{
+  objalloc_free_block ((struct objalloc *) abfd->memory, block);
 }