Subversion Repositories openrisc_me

/* opncls.c -- open and close a BFD.

   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,

   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009

   Free Software Foundation, Inc.

   Written by Cygnus Support.

   This file is part of BFD, the Binary File Descriptor library.

   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 3 of the License, or

   (at your option) any later version.

   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

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

#include "sysdep.h"

#include "bfd.h"

#include "objalloc.h"

#include "libbfd.h"

#include "libiberty.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.  */

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.  */

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

bfd *

_bfd_new_bfd (void)

{

  bfd *nbfd;

  nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));

  if (nbfd == NULL)

    return NULL;

  nbfd->id = _bfd_id_counter++;

  nbfd->memory = 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;

  if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,

                              sizeof (struct section_hash_entry), 251))

    {

      free (nbfd);

      return NULL;

    }

  nbfd->sections = NULL;

  nbfd->section_last = NULL;

  nbfd->format = bfd_unknown;

  nbfd->my_archive = NULL;

  nbfd->origin = 0;

  nbfd->opened_once = FALSE;

  nbfd->output_has_begun = FALSE;

  nbfd->section_count = 0;

  nbfd->usrdata = 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 (bfd *obfd)

{

  bfd *nbfd;

  nbfd = _bfd_new_bfd ();

  if (nbfd == NULL)

    return NULL;

  nbfd->xvec = obfd->xvec;

  nbfd->iovec = obfd->iovec;

  nbfd->my_archive = obfd;

  nbfd->direction = read_direction;

  nbfd->target_defaulted = obfd->target_defaulted;

  return nbfd;

}

/* Delete a BFD.  */

void

_bfd_delete_bfd (bfd *abfd)

{

  if (abfd->memory)

    {

      bfd_hash_table_free (&abfd->section_htab);

      objalloc_free ((struct objalloc *) abfd->memory);

    }

  free (abfd);

}

/* Free objalloc memory.  */

bfd_boolean

_bfd_free_cached_info (bfd *abfd)

{

  if (abfd->memory)

    {

      bfd_hash_table_free (&abfd->section_htab);

      objalloc_free ((struct objalloc *) abfd->memory);

      abfd->sections = NULL;

      abfd->section_last = NULL;

      abfd->outsymbols = NULL;

      abfd->tdata.any = NULL;

      abfd->usrdata = NULL;

      abfd->memory = NULL;

    }

  return TRUE;

}

/*

SECTION

        Opening and closing BFDs

SUBSECTION

        Functions for opening and closing

*/

/*

FUNCTION

        bfd_fopen

SYNOPSIS

        bfd *bfd_fopen (const char *filename, const char *target,

                        const char *mode, int fd);

DESCRIPTION

        Open the file @var{filename} with the target @var{target}.

        Return a pointer to the created BFD.  If @var{fd} is not -1,

        then <<fdopen>> is used to open the file; otherwise, <<fopen>>

        is used.  @var{mode} is passed directly to <<fopen>> or

        <<fdopen>>.

        Calls <<bfd_find_target>>, so @var{target} is interpreted as by

        that function.

        The new BFD is marked as cacheable iff @var{fd} is -1.

        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_fopen (const char *filename, const char *target, const char *mode, int fd)

{

  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;

    }

#ifdef HAVE_FDOPEN

  if (fd != -1)

    nbfd->iostream = fdopen (fd, mode);

  else

#endif

    nbfd->iostream = real_fopen (filename, mode);

  if (nbfd->iostream == NULL)

    {

      bfd_set_error (bfd_error_system_call);

      _bfd_delete_bfd (nbfd);

      return NULL;

    }

  /* OK, put everything where it belongs.  */

  nbfd->filename = filename;

  /* Figure out whether the user is opening the file for reading,

     writing, or both, by looking at the MODE argument.  */

  if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')

      && mode[1] == '+')

    nbfd->direction = both_direction;

  else if (mode[0] == 'r')

    nbfd->direction = read_direction;

  else

    nbfd->direction = write_direction;

  if (! bfd_cache_init (nbfd))

    {

      _bfd_delete_bfd (nbfd);

      return NULL;

    }

  nbfd->opened_once = TRUE;

  /* If we opened the file by name, mark it cacheable; we can close it

     and reopen it later.  However, if a file descriptor was provided,

     then it may have been opened with special flags that make it

     unsafe to close and reopen the file.  */

  if (fd == -1)

    bfd_set_cacheable (nbfd, TRUE);

  return nbfd;

}

/*

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 (const char *filename, const char *target)

{

  return bfd_fopen (filename, target, FOPEN_RB, -1);

}

/* 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.  */

/*

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 caching; 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 (const char *filename, const char *target, int fd)

{

  const char *mode;

#if defined(HAVE_FCNTL) && defined(F_GETFL)

  int fdflags;

#endif

#if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)

  mode = FOPEN_RUB; /* Assume full access.  */

#else

  fdflags = fcntl (fd, F_GETFL, NULL);

  if (fdflags == -1)

    {

      bfd_set_error (bfd_error_system_call);

      return NULL;

    }

  /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */

  switch (fdflags & (O_ACCMODE))

    {

    case O_RDONLY: mode = FOPEN_RB; break;

    case O_WRONLY: mode = FOPEN_RUB; break;

    case O_RDWR:   mode = FOPEN_RUB; break;

    default: abort ();

    }

#endif

  return bfd_fopen (filename, target, mode, fd);

}

/*

FUNCTION

        bfd_openstreamr

SYNOPSIS

        bfd *bfd_openstreamr (const char *, const char *, void *);

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 (const char *filename, const char *target, void *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 = stream;

  nbfd->filename = filename;

  nbfd->direction = read_direction;

  if (! bfd_cache_init (nbfd))

    {

      _bfd_delete_bfd (nbfd);

      return NULL;

    }

  return nbfd;

}

/*

FUNCTION

        bfd_openr_iovec

SYNOPSIS

        bfd *bfd_openr_iovec (const char *filename, const char *target,

                              void *(*open_func) (struct bfd *nbfd,

                                                  void *open_closure),

                              void *open_closure,

                              file_ptr (*pread_func) (struct bfd *nbfd,

                                                      void *stream,

                                                      void *buf,

                                                      file_ptr nbytes,

                                                      file_ptr offset),

                              int (*close_func) (struct bfd *nbfd,

                                                 void *stream),

                              int (*stat_func) (struct bfd *abfd,

                                                void *stream,

                                                struct stat *sb));

DESCRIPTION

        Create and return a BFD backed by a read-only @var{stream}.

        The @var{stream} is created using @var{open_func}, accessed using

        @var{pread_func} and destroyed using @var{close_func}.

        Calls <<bfd_find_target>>, so @var{target} is interpreted as by

        that function.

        Calls @var{open_func} (which can call <<bfd_zalloc>> and

        <<bfd_get_filename>>) to obtain the read-only stream backing

        the BFD.  @var{open_func} either succeeds returning the

        non-<<NULL>> @var{stream}, or fails returning <<NULL>>

        (setting <<bfd_error>>).

        Calls @var{pread_func} to request @var{nbytes} of data from

        @var{stream} starting at @var{offset} (e.g., via a call to

        <<bfd_read>>).  @var{pread_func} either succeeds returning the

        number of bytes read (which can be less than @var{nbytes} when

        end-of-file), or fails returning -1 (setting <<bfd_error>>).

        Calls @var{close_func} when the BFD is later closed using

        <<bfd_close>>.  @var{close_func} either succeeds returning 0, or

        fails returning -1 (setting <<bfd_error>>).

        Calls @var{stat_func} to fill in a stat structure for bfd_stat,

        bfd_get_size, and bfd_get_mtime calls.  @var{stat_func} returns 0

        on success, or returns -1 on failure (setting <<bfd_error>>).

        If <<bfd_openr_iovec>> returns <<NULL>> then an error has

        occurred.  Possible errors are <<bfd_error_no_memory>>,

        <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.

*/

struct opncls

{

  void *stream;

  file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,

                     file_ptr nbytes, file_ptr offset);

  int (*close) (struct bfd *abfd, void *stream);

  int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);

  file_ptr where;

};

static file_ptr

opncls_btell (struct bfd *abfd)

{

  struct opncls *vec = (struct opncls *) abfd->iostream;

  return vec->where;

}

static int

opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)

{

  struct opncls *vec = (struct opncls *) abfd->iostream;

  switch (whence)

    {

    case SEEK_SET: vec->where = offset; break;

    case SEEK_CUR: vec->where += offset; break;

    case SEEK_END: return -1;

    }

  return 0;

}

static file_ptr

opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)

{

  struct opncls *vec = (struct opncls *) abfd->iostream;

  file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);

  if (nread < 0)

    return nread;

  vec->where += nread;

  return nread;

}

static file_ptr

opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,

              const void *where ATTRIBUTE_UNUSED,

              file_ptr nbytes ATTRIBUTE_UNUSED)

{

  return -1;

}

static int

opncls_bclose (struct bfd *abfd)

{

  struct opncls *vec = (struct opncls *) abfd->iostream;

  /* Since the VEC's memory is bound to the bfd deleting the bfd will

     free it.  */

  int status = 0;

  if (vec->close != NULL)

    status = (vec->close) (abfd, vec->stream);

  abfd->iostream = NULL;

  return status;

}

static int

opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)

{

  return 0;

}

static int

opncls_bstat (struct bfd *abfd, struct stat *sb)

{

  struct opncls *vec = (struct opncls *) abfd->iostream;

  memset (sb, 0, sizeof (*sb));

  if (vec->stat == NULL)

    return 0;

  return (vec->stat) (abfd, vec->stream, sb);

}

static void *

opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,

              void *addr ATTRIBUTE_UNUSED,

              bfd_size_type len ATTRIBUTE_UNUSED,

              int prot ATTRIBUTE_UNUSED,

              int flags ATTRIBUTE_UNUSED,

              file_ptr offset ATTRIBUTE_UNUSED)

{

  return (void *) -1;

}

static const struct bfd_iovec opncls_iovec = {

  &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,

  &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap

};

bfd *

bfd_openr_iovec (const char *filename, const char *target,

                 void *(*open_p) (struct bfd *, void *),

                 void *open_closure,

                 file_ptr (*pread_p) (struct bfd *, void *, void *,

                                      file_ptr, file_ptr),

                 int (*close_p) (struct bfd *, void *),

                 int (*stat_p) (struct bfd *, void *, struct stat *))

{

  bfd *nbfd;

  const bfd_target *target_vec;

  struct opncls *vec;

  void *stream;

  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->direction = read_direction;

  /* `open_p (...)' would get expanded by an the open(2) syscall macro.  */

  stream = (*open_p) (nbfd, open_closure);

  if (stream == NULL)

    {

      _bfd_delete_bfd (nbfd);

      return NULL;

    }

  vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));

  vec->stream = stream;

  vec->pread = pread_p;

  vec->close = close_p;

  vec->stat = stat_p;

  nbfd->iovec = &opncls_iovec;

  nbfd->iostream = vec;

  return nbfd;

}

/* 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);

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 (const char *filename, const char *target)

{

  bfd *nbfd;

  const bfd_target *target_vec;

  /* 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)

    return NULL;

  target_vec = bfd_find_target (target, nbfd);

  if (target_vec == NULL)

    {

      _bfd_delete_bfd (nbfd);

      return NULL;

    }

  nbfd->filename = filename;

  nbfd->direction = write_direction;

  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;

}

static inline void

_maybe_make_executable (bfd * abfd)

{

  /* If the file was open for writing and is now executable,

     make it so.  */

  if (abfd->direction == write_direction

      && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)

    {

      struct stat buf;

      if (stat (abfd->filename, &buf) == 0

          /* Do not attempt to change non-regular files.  This is

             here especially for configure scripts and kernel builds

             which run tests with "ld [...] -o /dev/null".  */

          && S_ISREG(buf.st_mode))

        {

          unsigned int mask = umask (0);

          umask (mask);

          chmod (abfd->filename,

                 (0777

                  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));

        }

    }

}

/*

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 (bfd *abfd)

{

  bfd_boolean ret;

  bfd *nbfd;

  bfd *next;

  if (bfd_write_p (abfd))

    {

      if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))

        return FALSE;

    }

  /* Close nested archives (if this bfd is a thin archive).  */

  for (nbfd = abfd->nested_archives; nbfd; nbfd = next)

    {

      next = nbfd->archive_next;

      bfd_close (nbfd);

    }

  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))

    return FALSE;

  if ((abfd->flags & BFD_IN_MEMORY) != 0)

    {

      /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io

         vector.

         Until that's done, at least don't leak memory.  */

      struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;

      if (bim->buffer != NULL)

        free (bim->buffer);

      free (bim);

      ret = TRUE;

    }

  else

    ret = abfd->iovec->bclose (abfd);

  if (ret)

    _maybe_make_executable (abfd);

  _bfd_delete_bfd (abfd);

  return ret;

}

/*

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.