* coff-tic80.c (tic80coff_vec): Change to little endian data

[binutils.git] / bfd / opncls.c

diff --git a/bfd/opncls.c b/bfd/opncls.c
index 9b91c2fbe9e743babf2246fa22b0f28eb8cbb12e..ee8d152ceec862aee13a24e7c4d7609838b61301 100644 (file)
--- a/bfd/opncls.c
+++ b/bfd/opncls.c
@@ -1,71 +1,80 @@
-/* opncls.c -- open and close a bfd. */
+/* opncls.c -- open and close a BFD.
+   Copyright (C) 1990 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
+   Written by Cygnus Support.

 
 

-/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+This file is part of BFD, the Binary File Descriptor library.

 
 

-This file is part of BFD, the Binary File Diddler.
-
-BFD is free software; you can redistribute it and/or modify
+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
 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
 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$ */
+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 "bfd.h"

+#include "sysdep.h"

 #include "libbfd.h"
 #include "libbfd.h"

+#include "obstack.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.  */
 
 /* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
    if we do that we can't use fcntl.  */

-\f
-/** 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?... */

 
 #define obstack_chunk_alloc malloc
 #define obstack_chunk_free free
 
 
 #define obstack_chunk_alloc malloc
 #define obstack_chunk_free free
 

+#ifndef HAVE_GETPAGESIZE
+#define getpagesize()  2048
+#endif
+
+long _bfd_chunksize = -1;
+

 /* Return a new BFD.  All BFD's are allocated through this routine.  */
 
 /* Return a new BFD.  All BFD's are allocated through this routine.  */
 

-bfd *new_bfd()
+bfd *
+_bfd_new_bfd ()

 {
 {

-  struct obstack tmp;

   bfd *nbfd;
   bfd *nbfd;

-  obstack_begin(&tmp,128);
-  
-  nbfd = (bfd *)obstack_alloc(&tmp,sizeof(bfd));
-  memset((PTR)nbfd, 0, sizeof (bfd));          /* Clear it */

 
 

-  nbfd->memory = tmp;
+  nbfd = (bfd *)bfd_zmalloc (sizeof (bfd));
+  if (!nbfd)
+    return 0;
+
+  if (_bfd_chunksize <= 0)
+    {
+      _bfd_chunksize = getpagesize ();
+      if (_bfd_chunksize <= 0)
+       _bfd_chunksize = 2048;
+      /* Leave some slush space, since many malloc implementations
+        prepend a header, and may wind up wasting another page
+        because of it.  */
+      _bfd_chunksize -= 32;
+    }
+
+  if (!obstack_begin(&nbfd->memory, _bfd_chunksize))
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return 0;
+    }
+
+  nbfd->arch_info = &bfd_default_arch_struct;

 
   nbfd->direction = no_direction;
   nbfd->iostream = NULL;
 
   nbfd->direction = no_direction;
   nbfd->iostream = NULL;


@@ -73,60 +82,81 @@ bfd *new_bfd()
   nbfd->sections = (asection *)NULL;
   nbfd->format = bfd_unknown;
   nbfd->my_archive = (bfd *)NULL;
   nbfd->sections = (asection *)NULL;
   nbfd->format = bfd_unknown;
   nbfd->my_archive = (bfd *)NULL;

-  nbfd->origin = 0;                               
+  nbfd->origin = 0;                            

   nbfd->opened_once = false;
   nbfd->output_has_begun = false;
   nbfd->section_count = 0;
   nbfd->usrdata = (PTR)NULL;
   nbfd->opened_once = false;
   nbfd->output_has_begun = false;
   nbfd->section_count = 0;
   nbfd->usrdata = (PTR)NULL;

-  nbfd->sections = (asection *)NULL;

   nbfd->cacheable = false;
   nbfd->cacheable = false;

-  nbfd->flags = NO_FLAGS;
-  nbfd->mtime_set = 0;
+  nbfd->flags = BFD_NO_FLAGS;
+  nbfd->mtime_set = false;
+

   return nbfd;
 }
 
 /* Allocate a new BFD as a member of archive OBFD.  */
 
   return nbfd;
 }
 
 /* Allocate a new BFD as a member of archive OBFD.  */
 

-bfd *new_bfd_contained_in(obfd)
-bfd *obfd;
+bfd *
+_bfd_new_bfd_contained_in (obfd)
+     bfd *obfd;

 {
 {

-       bfd *nbfd = new_bfd();
-       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 <<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 *

-DEFUN(bfd_openr, (filename, target),
-      CONST char *filename AND
-      CONST char *target)
+bfd_openr (filename, target)
+     CONST char *filename;
+     CONST char *target;

 {
   bfd *nbfd;
 {
   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;
     return NULL;

-  }

 
 

-  bfd_error = system_call_error;
-  nbfd = new_bfd();
-  if (nbfd == NULL) {
-    bfd_error = no_memory;
+  target_vec = bfd_find_target (target, nbfd);
+  if (target_vec == NULL) {
+    bfd_set_error (bfd_error_invalid_target);

     return NULL;
   }
 
   nbfd->filename = filename;
     return NULL;
   }
 
   nbfd->filename = filename;

-  nbfd->xvec = target_vec;
-  nbfd->direction = read_direction; 
+  nbfd->direction = read_direction;

 
   if (bfd_open_file (nbfd) == NULL) {
 
   if (bfd_open_file (nbfd) == NULL) {

-    bfd_error = system_call_error;     /* File didn't exist, or some such */
+    bfd_set_error (bfd_error_system_call);     /* File didn't exist, or some such */

     bfd_release(nbfd,0);
     return NULL;
   }
     bfd_release(nbfd,0);
     return NULL;
   }


@@ -142,196 +172,434 @@ DEFUN(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.
  */
        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
+         <<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 *

-DEFUN(bfd_fdopenr,(filename, target, fd),
-      CONST char *filename AND
-      CONST char *target AND
-      int fd)
+bfd_fdopenr (filename, target, fd)
+     CONST char *filename;
+     CONST char *target;
+     int fd;

 {
   bfd *nbfd;
 {
   bfd *nbfd;

-  bfd_target *target_vec;
+  const bfd_target *target_vec;

   int fdflags;
   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;
-    return NULL;
-  }
-
-  bfd_error = system_call_error;
-  
-  fdflags = fcntl (fd, F_GETFL);
+  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;
 
   if (fdflags == -1) return NULL;
 

-#ifdef BFD_LOCKS
-  lockp->l_type = F_RDLCK;
-  if (fcntl (fd, F_SETLKW, lockp) == -1) return NULL;
-#endif
+  nbfd = _bfd_new_bfd();

 
 

-  nbfd = new_bfd();
+  if (nbfd == NULL)
+    return NULL;

 
 

-  if (nbfd == NULL) {
-    bfd_error = no_memory;
+  target_vec = bfd_find_target (target, nbfd);
+  if (target_vec == NULL) {
+    bfd_set_error (bfd_error_invalid_target);

     return NULL;
   }
     return NULL;
   }

-#ifdef BFD_LOCKS
-  nbfd->lock = (struct flock *) (nbfd + 1);
+#if defined(VMS) || defined(__GO32__) || defined (WINGDB)
+  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
 #endif

-  /* if the fd were open for read only, this still would not hurt: */
-  nbfd->iostream = (char *) fdopen (fd, "r+"); 

   if (nbfd->iostream == NULL) {
     (void) obstack_free (&nbfd->memory, (PTR)0);
     return NULL;
   }
   if (nbfd->iostream == NULL) {
     (void) obstack_free (&nbfd->memory, (PTR)0);
     return NULL;
   }

-  
+

   /* OK, put everything where it belongs */
 
   nbfd->filename = filename;
   /* 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.  */
 
   /* 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) {
+  /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
+  switch (fdflags & (O_ACCMODE)) {

   case O_RDONLY: nbfd->direction = read_direction; break;
   case O_RDONLY: nbfd->direction = read_direction; break;

-  case O_WRONLY: nbfd->direction = write_direction; break;  
+  case O_WRONLY: nbfd->direction = write_direction; break;

   case O_RDWR: nbfd->direction = both_direction; break;
   default: abort ();
   }
   case O_RDWR: nbfd->direction = both_direction; break;
   default: abort ();
   }

-                                  
-#ifdef BFD_LOCKS
-  memcpy (nbfd->lock, lockp, sizeof (struct flock))
-#endif
+                               
+  if (! bfd_cache_init (nbfd))
+    return NULL;
+  nbfd->opened_once = true;
+
+  return nbfd;
+}
+
+/*
+FUNCTION
+       bfd_openstreamr
+
+SYNOPSIS
+       bfd *bfd_openstreamr();

 
 

-    bfd_cache_init (nbfd);
+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, stream)
+     const char *filename;
+     const char *target;
+     FILE *stream;
+{
+  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);
+      return NULL;
+    }
+
+  nbfd->iostream = (PTR) stream;
+  nbfd->filename = filename;
+  nbfd->direction = read_direction;
+                               
+  if (! bfd_cache_init (nbfd))
+    return NULL;

 
   return nbfd;
 }
 \f
 /** bfd_openw -- open for writing.
 
   return nbfd;
 }
 \f
 /** 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. */
 
 
   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_error_system_call>>, <<bfd_error_no_memory>>,
+       <<bfd_error_invalid_target>>.
+*/
+

 bfd *
 bfd *

-DEFUN(bfd_openw,(filename, target),
-      CONST char *filename AND
-      CONST char *target)
+bfd_openw (filename, target)
+     CONST char *filename;
+     CONST char *target;

 {
   bfd *nbfd;
 {
   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 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;
     return NULL;

-  }
+
+  target_vec = bfd_find_target (target, nbfd);
+  if (target_vec == NULL) return NULL;

 
   nbfd->filename = filename;
 
   nbfd->filename = filename;

-  nbfd->xvec = target_vec;

   nbfd->direction = write_direction;
 
   if (bfd_open_file (nbfd) == NULL) {
   nbfd->direction = write_direction;
 
   if (bfd_open_file (nbfd) == NULL) {

-    bfd_error = system_call_error;     /* File not writeable, etc */
+    bfd_set_error (bfd_error_system_call);     /* File not writeable, etc */

     (void) obstack_free (&nbfd->memory, (PTR)0);
     return NULL;
   }
   return nbfd;
 }
 
     (void) obstack_free (&nbfd->memory, (PTR)0);
     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
+       <<chmod>> is called to mark it as such.
+
+       All memory attached to the BFD's obstacks 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>>.
+*/
+

 
 

-\f
-/** Close up shop, get your deposit back. */

 boolean
 bfd_close (abfd)
      bfd *abfd;
 {
 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))));
+       }
+    }
+
+  (void) obstack_free (&abfd->memory, (PTR)0);
+  (void) free (abfd);
+
+  return ret;
+}
+
+/*
+FUNCTION
+       bfd_close_all_done
+
+SYNOPSIS
+       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's obstacks is released.
+
+RETURNS
+       <<true>> is returned if all is ok, otherwise <<false>>.
+
+*/
+
+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))));
+       }
+    }

   (void) obstack_free (&abfd->memory, (PTR)0);
   (void) obstack_free (&abfd->memory, (PTR)0);

-  return true;
+  (void) free(abfd);
+  return ret;

 }
 
 }
 

-/* Create a bfd with no associated file or target.  */
+
+/*
+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
+
+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 *

-DEFUN(bfd_create,(filename, template),
-      CONST char *filename AND
-      CONST bfd *template)
+bfd_create (filename, templ)
+     CONST char *filename;
+     bfd *templ;

 {
 {

-  bfd *nbfd = new_bfd();
-  if (nbfd == (bfd *)NULL) {
-    bfd_error = no_memory;
+  bfd *nbfd = _bfd_new_bfd();
+  if (nbfd == (bfd *)NULL)

     return (bfd *)NULL;
     return (bfd *)NULL;

-  }

   nbfd->filename = filename;
   nbfd->filename = filename;

-  if(template) {
-    nbfd->xvec = template->xvec;
+  if(templ) {
+    nbfd->xvec = templ->xvec;

   }
   nbfd->direction = no_direction;
   bfd_set_format(nbfd, bfd_object);
   return nbfd;
 }
 
   }
   nbfd->direction = no_direction;
   bfd_set_format(nbfd, bfd_object);
   return nbfd;
 }
 

-/* Memory allocation */
+/*
+INTERNAL_FUNCTION
+       bfd_alloc_by_size_t
+
+SYNOPSIS
+       PTR bfd_alloc_by_size_t(bfd *abfd, size_t wanted);
+
+DESCRIPTION
+       Allocate a block of @var{wanted} bytes of memory in the obstack
+       attatched to <<abfd>> and return a pointer to it.
+*/

 
 

-DEFUN(PTR bfd_alloc, (abfd, size),
-      bfd *abfd AND
-      bfd_size_type size)
+
+PTR
+bfd_alloc_by_size_t (abfd, size)
+     bfd *abfd;
+     size_t size;

 {
 {

-  PTR res = obstack_alloc(&(abfd->memory), (int)size);
-  return res;
+  PTR ret;
+
+  ret = obstack_alloc (&(abfd->memory), size);
+  if (ret == NULL)
+    bfd_set_error (bfd_error_no_memory);
+  return ret;

 }
 
 }
 

-DEFUN(PTR bfd_zalloc,(abfd, size),
-      bfd *abfd AND
-      bfd_size_type size)
+void
+bfd_alloc_grow (abfd, ptr, size)
+     bfd *abfd;
+     PTR ptr;
+     size_t size;

 {
 {

-  PTR res = bfd_alloc(abfd, size);
-  memset(res, 0, (size_t)size);
-  return res;
+  (void) obstack_grow(&(abfd->memory), ptr, size);

 }
 
 }
 

-DEFUN(PTR bfd_realloc,(abfd, old, size),
-      bfd *abfd AND
-      PTR old AND
-      bfd_size_type size)
+PTR
+bfd_alloc_finish (abfd)
+     bfd *abfd;

 {
 {

-  PTR res = bfd_alloc(abfd, size);
-  memcpy(res, old, (size_t)size);
-  return res;
+  PTR ret;
+
+  ret = obstack_finish (&(abfd->memory));
+  if (ret == NULL)
+    bfd_set_error (bfd_error_no_memory);
+  return ret;

 }
 
 }
 

+PTR
+bfd_alloc (abfd, size)
+     bfd *abfd;
+     size_t size;
+{
+  return bfd_alloc_by_size_t(abfd, (size_t)size);
+}

 
 

-DEFUN(bfd_size_type bfd_alloc_size,(abfd),
-      bfd *abfd)
+PTR
+bfd_zalloc (abfd, size)
+     bfd *abfd;
+     size_t size;

 {
 {

-  struct _obstack_chunk *chunk = abfd->memory.chunk;
-  size_t size = 0;
-  while (chunk) {
-    size += chunk->limit - &(chunk->contents[0]);
-    chunk = chunk->prev;
-  }
-  return size;
+  PTR res;
+  res = bfd_alloc(abfd, size);
+  if (res)
+    memset(res, 0, (size_t)size);
+  return res;

 }
 }