OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [bfd/] [opncls.c] - Diff between revs 578 and 1765

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 578 Rev 1765
/* opncls.c -- open and close a BFD.
/* opncls.c -- open and close a BFD.
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
   2001
   2001
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
 
 
   Written by Cygnus Support.
   Written by Cygnus Support.
 
 
This file is part of BFD, the Binary File Descriptor library.
This file is part of BFD, the Binary File Descriptor library.
 
 
This program 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 2 of the License, or
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
(at your option) any later version.
 
 
This program 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
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
GNU General Public License for more details.
 
 
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 
#include "bfd.h"
#include "bfd.h"
#include "sysdep.h"
#include "sysdep.h"
#include "objalloc.h"
#include "objalloc.h"
#include "libbfd.h"
#include "libbfd.h"
 
 
#ifndef S_IXUSR
#ifndef S_IXUSR
#define S_IXUSR 0100    /* Execute by owner.  */
#define S_IXUSR 0100    /* Execute by owner.  */
#endif
#endif
#ifndef S_IXGRP
#ifndef S_IXGRP
#define S_IXGRP 0010    /* Execute by group.  */
#define S_IXGRP 0010    /* Execute by group.  */
#endif
#endif
#ifndef S_IXOTH
#ifndef S_IXOTH
#define S_IXOTH 0001    /* Execute by others.  */
#define S_IXOTH 0001    /* Execute by others.  */
#endif
#endif
 
 
/* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
/* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
   if we do that we can't use fcntl.  */
   if we do that we can't use fcntl.  */
 
 
/* FIXME: This is no longer used.  */
/* FIXME: This is no longer used.  */
long _bfd_chunksize = -1;
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 *
bfd *
_bfd_new_bfd ()
_bfd_new_bfd ()
{
{
  bfd *nbfd;
  bfd *nbfd;
 
 
  nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
  nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
  if (nbfd == NULL)
  if (nbfd == NULL)
    return NULL;
    return NULL;
 
 
  nbfd->memory = (PTR) objalloc_create ();
  nbfd->memory = (PTR) objalloc_create ();
  if (nbfd->memory == NULL)
  if (nbfd->memory == NULL)
    {
    {
      bfd_set_error (bfd_error_no_memory);
      bfd_set_error (bfd_error_no_memory);
      return NULL;
      return NULL;
    }
    }
 
 
  nbfd->arch_info = &bfd_default_arch_struct;
  nbfd->arch_info = &bfd_default_arch_struct;
 
 
  nbfd->direction = no_direction;
  nbfd->direction = no_direction;
  nbfd->iostream = NULL;
  nbfd->iostream = NULL;
  nbfd->where = 0;
  nbfd->where = 0;
  nbfd->sections = (asection *) NULL;
  nbfd->sections = (asection *) NULL;
  nbfd->format = bfd_unknown;
  nbfd->format = bfd_unknown;
  nbfd->my_archive = (bfd *) NULL;
  nbfd->my_archive = (bfd *) NULL;
  nbfd->origin = 0;
  nbfd->origin = 0;
  nbfd->opened_once = false;
  nbfd->opened_once = false;
  nbfd->output_has_begun = false;
  nbfd->output_has_begun = false;
  nbfd->section_count = 0;
  nbfd->section_count = 0;
  nbfd->usrdata = (PTR) NULL;
  nbfd->usrdata = (PTR) NULL;
  nbfd->cacheable = false;
  nbfd->cacheable = false;
  nbfd->flags = BFD_NO_FLAGS;
  nbfd->flags = BFD_NO_FLAGS;
  nbfd->mtime_set = false;
  nbfd->mtime_set = false;
 
 
  return nbfd;
  return nbfd;
}
}
 
 
/* Allocate a new BFD as a member of archive OBFD.  */
/* Allocate a new BFD as a member of archive OBFD.  */
 
 
bfd *
bfd *
_bfd_new_bfd_contained_in (obfd)
_bfd_new_bfd_contained_in (obfd)
     bfd *obfd;
     bfd *obfd;
{
{
  bfd *nbfd;
  bfd *nbfd;
 
 
  nbfd = _bfd_new_bfd ();
  nbfd = _bfd_new_bfd ();
  nbfd->xvec = obfd->xvec;
  nbfd->xvec = obfd->xvec;
  nbfd->my_archive = obfd;
  nbfd->my_archive = obfd;
  nbfd->direction = read_direction;
  nbfd->direction = read_direction;
  nbfd->target_defaulted = obfd->target_defaulted;
  nbfd->target_defaulted = obfd->target_defaulted;
  return nbfd;
  return nbfd;
}
}
 
 
/*
/*
SECTION
SECTION
        Opening and closing BFDs
        Opening and closing BFDs
 
 
*/
*/
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_openr
        bfd_openr
 
 
SYNOPSIS
SYNOPSIS
        bfd *bfd_openr(CONST char *filename, CONST char *target);
        bfd *bfd_openr(CONST char *filename, CONST char *target);
 
 
DESCRIPTION
DESCRIPTION
        Open the file @var{filename} (using <<fopen>>) with the target
        Open the file @var{filename} (using <<fopen>>) with the target
        @var{target}.  Return a pointer to the created BFD.
        @var{target}.  Return a pointer to the created BFD.
 
 
        Calls <<bfd_find_target>>, so @var{target} is interpreted as by
        Calls <<bfd_find_target>>, so @var{target} is interpreted as by
        that function.
        that function.
 
 
        If <<NULL>> is returned then an error has occured.   Possible errors
        If <<NULL>> is returned then an error has occured.   Possible errors
        are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or <<system_call>> error.
        are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or <<system_call>> error.
*/
*/
 
 
bfd *
bfd *
bfd_openr (filename, target)
bfd_openr (filename, target)
     CONST char *filename;
     CONST char *filename;
     CONST char *target;
     CONST char *target;
{
{
  bfd *nbfd;
  bfd *nbfd;
  const bfd_target *target_vec;
  const bfd_target *target_vec;
 
 
  nbfd = _bfd_new_bfd ();
  nbfd = _bfd_new_bfd ();
  if (nbfd == NULL)
  if (nbfd == NULL)
    return NULL;
    return NULL;
 
 
  target_vec = bfd_find_target (target, nbfd);
  target_vec = bfd_find_target (target, nbfd);
  if (target_vec == NULL)
  if (target_vec == NULL)
    {
    {
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      bfd_set_error (bfd_error_invalid_target);
      bfd_set_error (bfd_error_invalid_target);
      return NULL;
      return NULL;
    }
    }
 
 
  nbfd->filename = filename;
  nbfd->filename = filename;
  nbfd->direction = read_direction;
  nbfd->direction = read_direction;
 
 
  if (bfd_open_file (nbfd) == NULL)
  if (bfd_open_file (nbfd) == NULL)
    {
    {
      /* File didn't exist, or some such */
      /* File didn't exist, or some such */
      bfd_set_error (bfd_error_system_call);
      bfd_set_error (bfd_error_system_call);
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      return NULL;
      return NULL;
    }
    }
 
 
  return nbfd;
  return nbfd;
}
}
 
 
/* Don't try to `optimize' this function:
/* Don't try to `optimize' this function:
 
 
   o - We lock using stack space so that interrupting the locking
   o - We lock using stack space so that interrupting the locking
       won't cause a storage leak.
       won't cause a storage leak.
   o - We open the file stream last, since we don't want to have to
   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
       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
FUNCTION
         bfd_fdopenr
         bfd_fdopenr
 
 
SYNOPSIS
SYNOPSIS
         bfd *bfd_fdopenr(CONST char *filename, CONST char *target, int fd);
         bfd *bfd_fdopenr(CONST char *filename, CONST char *target, int fd);
 
 
DESCRIPTION
DESCRIPTION
         <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to <<fopen>>.
         <<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}
         It opens a BFD on a file already described by the @var{fd}
         supplied.
         supplied.
 
 
         When the file is later <<bfd_close>>d, the file descriptor will be closed.
         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
         If the caller desires that this file descriptor be cached by BFD
         (opened as needed, closed as needed to free descriptors for
         (opened as needed, closed as needed to free descriptors for
         other opens), with the supplied @var{fd} used as an initial
         other opens), with the supplied @var{fd} used as an initial
         file descriptor (but subject to closure at any time), call
         file descriptor (but subject to closure at any time), call
         bfd_set_cacheable(bfd, 1) on the returned BFD.  The default is to
         bfd_set_cacheable(bfd, 1) on the returned BFD.  The default is to
         assume no cacheing; the file descriptor will remain open until
         assume no cacheing; the file descriptor will remain open until
         <<bfd_close>>, and will not be affected by BFD operations on other
         <<bfd_close>>, and will not be affected by BFD operations on other
         files.
         files.
 
 
         Possible errors are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
         Possible errors are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
*/
*/
 
 
bfd *
bfd *
bfd_fdopenr (filename, target, fd)
bfd_fdopenr (filename, target, fd)
     CONST char *filename;
     CONST char *filename;
     CONST char *target;
     CONST char *target;
     int fd;
     int fd;
{
{
  bfd *nbfd;
  bfd *nbfd;
  const bfd_target *target_vec;
  const bfd_target *target_vec;
  int fdflags;
  int fdflags;
 
 
  bfd_set_error (bfd_error_system_call);
  bfd_set_error (bfd_error_system_call);
#if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
#if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
  fdflags = O_RDWR;                     /* Assume full access */
  fdflags = O_RDWR;                     /* Assume full access */
#else
#else
  fdflags = fcntl (fd, F_GETFL, NULL);
  fdflags = fcntl (fd, F_GETFL, NULL);
#endif
#endif
  if (fdflags == -1) return NULL;
  if (fdflags == -1) return NULL;
 
 
  nbfd = _bfd_new_bfd ();
  nbfd = _bfd_new_bfd ();
  if (nbfd == NULL)
  if (nbfd == NULL)
    return NULL;
    return NULL;
 
 
  target_vec = bfd_find_target (target, nbfd);
  target_vec = bfd_find_target (target, nbfd);
  if (target_vec == NULL)
  if (target_vec == NULL)
    {
    {
      bfd_set_error (bfd_error_invalid_target);
      bfd_set_error (bfd_error_invalid_target);
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      return NULL;
      return NULL;
    }
    }
 
 
#ifndef HAVE_FDOPEN
#ifndef HAVE_FDOPEN
  nbfd->iostream = (PTR) fopen (filename, FOPEN_RB);
  nbfd->iostream = (PTR) fopen (filename, FOPEN_RB);
#else
#else
  /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
  /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
  switch (fdflags & (O_ACCMODE))
  switch (fdflags & (O_ACCMODE))
    {
    {
    case O_RDONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RB);   break;
    case O_RDONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RB);   break;
    case O_WRONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB);  break;
    case O_WRONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB);  break;
    case O_RDWR:   nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB);  break;
    case O_RDWR:   nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB);  break;
    default: abort ();
    default: abort ();
    }
    }
#endif
#endif
 
 
  if (nbfd->iostream == NULL)
  if (nbfd->iostream == NULL)
    {
    {
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      return NULL;
      return NULL;
    }
    }
 
 
  /* OK, put everything where it belongs */
  /* OK, put everything where it belongs */
 
 
  nbfd->filename = filename;
  nbfd->filename = filename;
 
 
  /* As a special case we allow a FD open for read/write to
  /* As a special case we allow a FD open for read/write to
     be written through, although doing so requires that we end
     be written through, although doing so requires that we end
     the previous clause with a preposition.  */
     the previous clause with a preposition.  */
  /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
  /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
  switch (fdflags & (O_ACCMODE))
  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;
    case O_RDWR: nbfd->direction = both_direction; break;
    default: abort ();
    default: abort ();
    }
    }
 
 
  if (! bfd_cache_init (nbfd))
  if (! bfd_cache_init (nbfd))
    {
    {
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      return NULL;
      return NULL;
    }
    }
  nbfd->opened_once = true;
  nbfd->opened_once = true;
 
 
  return nbfd;
  return nbfd;
}
}
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_openstreamr
        bfd_openstreamr
 
 
SYNOPSIS
SYNOPSIS
        bfd *bfd_openstreamr(const char *, const char *, PTR);
        bfd *bfd_openstreamr(const char *, const char *, PTR);
 
 
DESCRIPTION
DESCRIPTION
 
 
        Open a BFD for read access on an existing stdio stream.  When
        Open a BFD for read access on an existing stdio stream.  When
        the BFD is passed to <<bfd_close>>, the stream will be closed.
        the BFD is passed to <<bfd_close>>, the stream will be closed.
*/
*/
 
 
bfd *
bfd *
bfd_openstreamr (filename, target, streamarg)
bfd_openstreamr (filename, target, streamarg)
     const char *filename;
     const char *filename;
     const char *target;
     const char *target;
     PTR streamarg;
     PTR streamarg;
{
{
  FILE *stream = (FILE *) streamarg;
  FILE *stream = (FILE *) streamarg;
  bfd *nbfd;
  bfd *nbfd;
  const bfd_target *target_vec;
  const bfd_target *target_vec;
 
 
  nbfd = _bfd_new_bfd ();
  nbfd = _bfd_new_bfd ();
  if (nbfd == NULL)
  if (nbfd == NULL)
    return NULL;
    return NULL;
 
 
  target_vec = bfd_find_target (target, nbfd);
  target_vec = bfd_find_target (target, nbfd);
  if (target_vec == NULL)
  if (target_vec == NULL)
    {
    {
      bfd_set_error (bfd_error_invalid_target);
      bfd_set_error (bfd_error_invalid_target);
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      return NULL;
      return NULL;
    }
    }
 
 
  nbfd->iostream = (PTR) stream;
  nbfd->iostream = (PTR) stream;
  nbfd->filename = filename;
  nbfd->filename = filename;
  nbfd->direction = read_direction;
  nbfd->direction = read_direction;
 
 
  if (! bfd_cache_init (nbfd))
  if (! bfd_cache_init (nbfd))
    {
    {
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      return NULL;
      return NULL;
    }
    }
 
 
  return nbfd;
  return nbfd;
}
}


/** bfd_openw -- open for writing.
/** 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
FUNCTION
        bfd_openw
        bfd_openw
 
 
SYNOPSIS
SYNOPSIS
        bfd *bfd_openw(CONST char *filename, CONST char *target);
        bfd *bfd_openw(CONST char *filename, CONST char *target);
 
 
DESCRIPTION
DESCRIPTION
        Create a BFD, associated with file @var{filename}, using the
        Create a BFD, associated with file @var{filename}, using the
        file format @var{target}, and return a pointer to it.
        file format @var{target}, and return a pointer to it.
 
 
        Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
        Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
        <<bfd_error_invalid_target>>.
        <<bfd_error_invalid_target>>.
*/
*/
 
 
bfd *
bfd *
bfd_openw (filename, target)
bfd_openw (filename, target)
     CONST char *filename;
     CONST char *filename;
     CONST char *target;
     CONST char *target;
{
{
  bfd *nbfd;
  bfd *nbfd;
  const bfd_target *target_vec;
  const bfd_target *target_vec;
 
 
  bfd_set_error (bfd_error_system_call);
  bfd_set_error (bfd_error_system_call);
 
 
  /* nbfd has to point to head of malloc'ed block so that bfd_close may
  /* nbfd has to point to head of malloc'ed block so that bfd_close may
     reclaim it correctly. */
     reclaim it correctly. */
 
 
  nbfd = _bfd_new_bfd ();
  nbfd = _bfd_new_bfd ();
  if (nbfd == NULL)
  if (nbfd == NULL)
    return NULL;
    return NULL;
 
 
  target_vec = bfd_find_target (target, nbfd);
  target_vec = bfd_find_target (target, nbfd);
  if (target_vec == NULL)
  if (target_vec == NULL)
    {
    {
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      return NULL;
      return NULL;
    }
    }
 
 
  nbfd->filename = filename;
  nbfd->filename = filename;
  nbfd->direction = write_direction;
  nbfd->direction = write_direction;
 
 
  if (bfd_open_file (nbfd) == NULL)
  if (bfd_open_file (nbfd) == NULL)
    {
    {
      bfd_set_error (bfd_error_system_call);    /* File not writeable, etc */
      bfd_set_error (bfd_error_system_call);    /* File not writeable, etc */
      objalloc_free ((struct objalloc *) nbfd->memory);
      objalloc_free ((struct objalloc *) nbfd->memory);
      free (nbfd);
      free (nbfd);
      return NULL;
      return NULL;
  }
  }
 
 
  return nbfd;
  return nbfd;
}
}
 
 
/*
/*
 
 
FUNCTION
FUNCTION
        bfd_close
        bfd_close
 
 
SYNOPSIS
SYNOPSIS
        boolean bfd_close(bfd *abfd);
        boolean bfd_close(bfd *abfd);
 
 
DESCRIPTION
DESCRIPTION
 
 
        Close a BFD. If the BFD was open for writing,
        Close a BFD. If the BFD was open for writing,
        then pending operations are completed and the file written out
        then pending operations are completed and the file written out
        and closed. If the created file is executable, then
        and closed. If the created file is executable, then
        <<chmod>> is called to mark it as such.
        <<chmod>> is called to mark it as such.
 
 
        All memory attached to the BFD is released.
        All memory attached to the BFD is released.
 
 
        The file descriptor associated with the BFD is closed (even
        The file descriptor associated with the BFD is closed (even
        if it was passed in to BFD by <<bfd_fdopenr>>).
        if it was passed in to BFD by <<bfd_fdopenr>>).
 
 
RETURNS
RETURNS
        <<true>> is returned if all is ok, otherwise <<false>>.
        <<true>> is returned if all is ok, otherwise <<false>>.
*/
*/
 
 
 
 
boolean
boolean
bfd_close (abfd)
bfd_close (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  boolean ret;
  boolean ret;
 
 
  if (!bfd_read_p (abfd))
  if (!bfd_read_p (abfd))
    {
    {
      if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
      if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
        return false;
        return false;
    }
    }
 
 
  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
    return false;
    return false;
 
 
  ret = bfd_cache_close (abfd);
  ret = bfd_cache_close (abfd);
 
 
  /* If the file was open for writing and is now executable,
  /* If the file was open for writing and is now executable,
     make it so */
     make it so */
  if (ret
  if (ret
      && abfd->direction == write_direction
      && abfd->direction == write_direction
      && abfd->flags & EXEC_P)
      && abfd->flags & EXEC_P)
    {
    {
      struct stat buf;
      struct stat buf;
 
 
      if (stat (abfd->filename, &buf) == 0)
      if (stat (abfd->filename, &buf) == 0)
        {
        {
          int mask = umask (0);
          int mask = umask (0);
          umask (mask);
          umask (mask);
          chmod (abfd->filename,
          chmod (abfd->filename,
                 (0777
                 (0777
                  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
                  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
        }
        }
    }
    }
 
 
  objalloc_free ((struct objalloc *) abfd->memory);
  objalloc_free ((struct objalloc *) abfd->memory);
  free (abfd);
  free (abfd);
 
 
  return ret;
  return ret;
}
}
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_close_all_done
        bfd_close_all_done
 
 
SYNOPSIS
SYNOPSIS
        boolean bfd_close_all_done(bfd *);
        boolean bfd_close_all_done(bfd *);
 
 
DESCRIPTION
DESCRIPTION
        Close a BFD.  Differs from <<bfd_close>>
        Close a BFD.  Differs from <<bfd_close>>
        since it does not complete any pending operations.  This
        since it does not complete any pending operations.  This
        routine would be used if the application had just used BFD for
        routine would be used if the application had just used BFD for
        swapping and didn't want to use any of the writing code.
        swapping and didn't want to use any of the writing code.
 
 
        If the created file is executable, then <<chmod>> is called
        If the created file is executable, then <<chmod>> is called
        to mark it as such.
        to mark it as such.
 
 
        All memory attached to the BFD is released.
        All memory attached to the BFD is released.
 
 
RETURNS
RETURNS
        <<true>> is returned if all is ok, otherwise <<false>>.
        <<true>> is returned if all is ok, otherwise <<false>>.
 
 
*/
*/
 
 
boolean
boolean
bfd_close_all_done (abfd)
bfd_close_all_done (abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  boolean ret;
  boolean ret;
 
 
  ret = bfd_cache_close (abfd);
  ret = bfd_cache_close (abfd);
 
 
  /* If the file was open for writing and is now executable,
  /* If the file was open for writing and is now executable,
     make it so */
     make it so */
  if (ret
  if (ret
      && abfd->direction == write_direction
      && abfd->direction == write_direction
      && abfd->flags & EXEC_P)
      && abfd->flags & EXEC_P)
    {
    {
      struct stat buf;
      struct stat buf;
 
 
      if (stat (abfd->filename, &buf) == 0)
      if (stat (abfd->filename, &buf) == 0)
        {
        {
          int mask = umask (0);
          int mask = umask (0);
          umask (mask);
          umask (mask);
          chmod (abfd->filename,
          chmod (abfd->filename,
                 (0777
                 (0777
                  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
                  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
        }
        }
    }
    }
 
 
  objalloc_free ((struct objalloc *) abfd->memory);
  objalloc_free ((struct objalloc *) abfd->memory);
  free (abfd);
  free (abfd);
 
 
  return ret;
  return ret;
}
}
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_create
        bfd_create
 
 
SYNOPSIS
SYNOPSIS
        bfd *bfd_create(CONST char *filename, bfd *templ);
        bfd *bfd_create(CONST char *filename, bfd *templ);
 
 
DESCRIPTION
DESCRIPTION
        Create a new BFD in the manner of
        Create a new BFD in the manner of
        <<bfd_openw>>, but without opening a file. The new BFD
        <<bfd_openw>>, but without opening a file. The new BFD
        takes the target from the target used by @var{template}. The
        takes the target from the target used by @var{template}. The
        format is always set to <<bfd_object>>.
        format is always set to <<bfd_object>>.
 
 
*/
*/
 
 
bfd *
bfd *
bfd_create (filename, templ)
bfd_create (filename, templ)
     CONST char *filename;
     CONST char *filename;
     bfd *templ;
     bfd *templ;
{
{
  bfd *nbfd;
  bfd *nbfd;
 
 
  nbfd = _bfd_new_bfd ();
  nbfd = _bfd_new_bfd ();
  if (nbfd == NULL)
  if (nbfd == NULL)
    return NULL;
    return NULL;
  nbfd->filename = filename;
  nbfd->filename = filename;
  if (templ)
  if (templ)
    nbfd->xvec = templ->xvec;
    nbfd->xvec = templ->xvec;
  nbfd->direction = no_direction;
  nbfd->direction = no_direction;
  bfd_set_format (nbfd, bfd_object);
  bfd_set_format (nbfd, bfd_object);
  return nbfd;
  return nbfd;
}
}
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_make_writable
        bfd_make_writable
 
 
SYNOPSIS
SYNOPSIS
        boolean bfd_make_writable(bfd *abfd);
        boolean bfd_make_writable(bfd *abfd);
 
 
DESCRIPTION
DESCRIPTION
        Takes a BFD as created by <<bfd_create>> and converts it
        Takes a BFD as created by <<bfd_create>> and converts it
        into one like as returned by <<bfd_openw>>.  It does this
        into one like as returned by <<bfd_openw>>.  It does this
        by converting the BFD to BFD_IN_MEMORY.  It's assumed that
        by converting the BFD to BFD_IN_MEMORY.  It's assumed that
        you will call <<bfd_make_readable>> on this bfd later.
        you will call <<bfd_make_readable>> on this bfd later.
 
 
RETURNS
RETURNS
        <<true>> is returned if all is ok, otherwise <<false>>.
        <<true>> is returned if all is ok, otherwise <<false>>.
*/
*/
 
 
boolean
boolean
bfd_make_writable(abfd)
bfd_make_writable(abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  struct bfd_in_memory *bim;
  struct bfd_in_memory *bim;
 
 
  if (abfd->direction != no_direction)
  if (abfd->direction != no_direction)
    {
    {
      bfd_set_error (bfd_error_invalid_operation);
      bfd_set_error (bfd_error_invalid_operation);
      return false;
      return false;
    }
    }
 
 
  bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
  bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
  abfd->iostream = (PTR) bim;
  abfd->iostream = (PTR) bim;
  /* bfd_write will grow these as needed */
  /* bfd_write will grow these as needed */
  bim->size = 0;
  bim->size = 0;
  bim->buffer = 0;
  bim->buffer = 0;
 
 
  abfd->flags |= BFD_IN_MEMORY;
  abfd->flags |= BFD_IN_MEMORY;
  abfd->direction = write_direction;
  abfd->direction = write_direction;
  abfd->where = 0;
  abfd->where = 0;
 
 
  return true;
  return true;
}
}
 
 
/*
/*
FUNCTION
FUNCTION
        bfd_make_readable
        bfd_make_readable
 
 
SYNOPSIS
SYNOPSIS
        boolean bfd_make_readable(bfd *abfd);
        boolean bfd_make_readable(bfd *abfd);
 
 
DESCRIPTION
DESCRIPTION
        Takes a BFD as created by <<bfd_create>> and
        Takes a BFD as created by <<bfd_create>> and
        <<bfd_make_writable>> and converts it into one like as
        <<bfd_make_writable>> and converts it into one like as
        returned by <<bfd_openr>>.  It does this by writing the
        returned by <<bfd_openr>>.  It does this by writing the
        contents out to the memory buffer, then reversing the
        contents out to the memory buffer, then reversing the
        direction.
        direction.
 
 
RETURNS
RETURNS
        <<true>> is returned if all is ok, otherwise <<false>>.  */
        <<true>> is returned if all is ok, otherwise <<false>>.  */
 
 
boolean
boolean
bfd_make_readable(abfd)
bfd_make_readable(abfd)
     bfd *abfd;
     bfd *abfd;
{
{
  if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
  if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
    {
    {
      bfd_set_error (bfd_error_invalid_operation);
      bfd_set_error (bfd_error_invalid_operation);
      return false;
      return false;
    }
    }
 
 
  if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
  if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
    return false;
    return false;
 
 
  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
    return false;
    return false;
 
 
 
 
  abfd->arch_info = &bfd_default_arch_struct;
  abfd->arch_info = &bfd_default_arch_struct;
 
 
  abfd->where = 0;
  abfd->where = 0;
  abfd->sections = (asection *) NULL;
  abfd->sections = (asection *) NULL;
  abfd->format = bfd_unknown;
  abfd->format = bfd_unknown;
  abfd->my_archive = (bfd *) NULL;
  abfd->my_archive = (bfd *) NULL;
  abfd->origin = 0;
  abfd->origin = 0;
  abfd->opened_once = false;
  abfd->opened_once = false;
  abfd->output_has_begun = false;
  abfd->output_has_begun = false;
  abfd->section_count = 0;
  abfd->section_count = 0;
  abfd->usrdata = (PTR) NULL;
  abfd->usrdata = (PTR) NULL;
  abfd->cacheable = false;
  abfd->cacheable = false;
  abfd->flags = BFD_IN_MEMORY;
  abfd->flags = BFD_IN_MEMORY;
  abfd->mtime_set = false;
  abfd->mtime_set = false;
 
 
  abfd->target_defaulted = true;
  abfd->target_defaulted = true;
  abfd->direction = read_direction;
  abfd->direction = read_direction;
  abfd->sections = 0;
  abfd->sections = 0;
  abfd->symcount = 0;
  abfd->symcount = 0;
  abfd->outsymbols = 0;
  abfd->outsymbols = 0;
  abfd->tdata.any = 0;
  abfd->tdata.any = 0;
 
 
  bfd_check_format(abfd, bfd_object);
  bfd_check_format(abfd, bfd_object);
 
 
  return true;
  return true;
}
}
 
 
/*
/*
INTERNAL_FUNCTION
INTERNAL_FUNCTION
        bfd_alloc
        bfd_alloc
 
 
SYNOPSIS
SYNOPSIS
        PTR bfd_alloc (bfd *abfd, size_t wanted);
        PTR bfd_alloc (bfd *abfd, size_t wanted);
 
 
DESCRIPTION
DESCRIPTION
        Allocate a block of @var{wanted} bytes of memory attached to
        Allocate a block of @var{wanted} bytes of memory attached to
        <<abfd>> and return a pointer to it.
        <<abfd>> and return a pointer to it.
*/
*/
 
 
 
 
PTR
PTR
bfd_alloc (abfd, size)
bfd_alloc (abfd, size)
     bfd *abfd;
     bfd *abfd;
     size_t size;
     size_t size;
{
{
  PTR ret;
  PTR ret;
 
 
  ret = objalloc_alloc (abfd->memory, (unsigned long) size);
  ret = objalloc_alloc (abfd->memory, (unsigned long) size);
  if (ret == NULL)
  if (ret == NULL)
    bfd_set_error (bfd_error_no_memory);
    bfd_set_error (bfd_error_no_memory);
  return ret;
  return ret;
}
}
 
 
PTR
PTR
bfd_zalloc (abfd, size)
bfd_zalloc (abfd, size)
     bfd *abfd;
     bfd *abfd;
     size_t size;
     size_t size;
{
{
  PTR res;
  PTR res;
 
 
  res = bfd_alloc (abfd, size);
  res = bfd_alloc (abfd, size);
  if (res)
  if (res)
    memset (res, 0, size);
    memset (res, 0, size);
  return res;
  return res;
}
}
 
 
/* Free a block allocated for a BFD.  */
/* Free a block allocated for a BFD.  */
 
 
void
void
bfd_release (abfd, block)
bfd_release (abfd, block)
     bfd *abfd;
     bfd *abfd;
     PTR block;
     PTR block;
{
{
  objalloc_free_block ((struct objalloc *) abfd->memory, block);
  objalloc_free_block ((struct objalloc *) abfd->memory, block);
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.