Back to index

cell-binutils  2.17cvs20070401
Defines | Functions
bfdio.c File Reference
#include "sysdep.h"
#include "bfd.h"
#include "libbfd.h"
#include <limits.h>

Go to the source code of this file.

Defines

#define S_IXUSR   0100 /* Execute by owner. */
#define S_IXGRP   0010 /* Execute by group. */
#define S_IXOTH   0001 /* Execute by others. */

Functions

file_ptr real_ftell (FILE *file)
int real_fseek (FILE *file, file_ptr offset, int whence)
FILE * real_fopen (const char *filename, const char *modes)
bfd_size_type bfd_bread (void *ptr, bfd_size_type size, bfd *abfd)
bfd_size_type bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd)
file_ptr bfd_tell (bfd *abfd)
int bfd_flush (bfd *abfd)
int bfd_stat (bfd *abfd, struct stat *statbuf)
int bfd_seek (bfd *abfd, file_ptr position, int direction)
long bfd_get_mtime (bfd *abfd)
file_ptr bfd_get_size (bfd *abfd)

Define Documentation

#define S_IXGRP   0010 /* Execute by group. */

Definition at line 36 of file bfdio.c.

#define S_IXOTH   0001 /* Execute by others. */

Definition at line 39 of file bfdio.c.

#define S_IXUSR   0100 /* Execute by owner. */

Definition at line 33 of file bfdio.c.


Function Documentation

bfd_size_type bfd_bread ( void *  ptr,
bfd_size_type  size,
bfd abfd 
)

Definition at line 115 of file bfdio.c.

{
  size_t nread;

  /* If this is an archive element, don't read past the end of
     this element.  */
  if (abfd->arelt_data != NULL)
    {
      size_t maxbytes = ((struct areltdata *) abfd->arelt_data)->parsed_size;
      if (size > maxbytes)
       size = maxbytes;
    }

  if ((abfd->flags & BFD_IN_MEMORY) != 0)
    {
      struct bfd_in_memory *bim;
      bfd_size_type get;

      bim = abfd->iostream;
      get = size;
      if (abfd->where + get > bim->size)
       {
         if (bim->size < (bfd_size_type) abfd->where)
           get = 0;
         else
           get = bim->size - abfd->where;
         bfd_set_error (bfd_error_file_truncated);
       }
      memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
      abfd->where += get;
      return get;
    }

  if (abfd->iovec)
    nread = abfd->iovec->bread (abfd, ptr, size);
  else
    nread = 0;
  if (nread != (size_t) -1)
    abfd->where += nread;

  return nread;
}

Here is the call graph for this function:

bfd_size_type bfd_bwrite ( const void *  ptr,
bfd_size_type  size,
bfd abfd 
)

Definition at line 159 of file bfdio.c.

{
  size_t nwrote;

  if ((abfd->flags & BFD_IN_MEMORY) != 0)
    {
      struct bfd_in_memory *bim = abfd->iostream;

      size = (size_t) size;
      if (abfd->where + size > bim->size)
       {
         bfd_size_type newsize, oldsize;

         oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
         bim->size = abfd->where + size;
         /* Round up to cut down on memory fragmentation */
         newsize = (bim->size + 127) & ~(bfd_size_type) 127;
         if (newsize > oldsize)
           {
             bim->buffer = bfd_realloc (bim->buffer, newsize);
             if (bim->buffer == 0)
              {
                bim->size = 0;
                return 0;
              }
           }
       }
      memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
      abfd->where += size;
      return size;
    }

  if (abfd->iovec)
    nwrote = abfd->iovec->bwrite (abfd, ptr, size);
  else
    nwrote = 0;

  if (nwrote != (size_t) -1)
    abfd->where += nwrote;
  if (nwrote != size)
    {
#ifdef ENOSPC
      errno = ENOSPC;
#endif
      bfd_set_error (bfd_error_system_call);
    }
  return nwrote;
}

Here is the call graph for this function:

int bfd_flush ( bfd abfd)

Definition at line 231 of file bfdio.c.

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

  if (abfd->iovec)
    return abfd->iovec->bflush (abfd);
  return 0;
}

Here is the caller graph for this function:

long bfd_get_mtime ( bfd abfd)

Definition at line 391 of file bfdio.c.

{
  struct stat buf;

  if (abfd->mtime_set)
    return abfd->mtime;

  if (abfd->iovec == NULL)
    return 0;

  if (abfd->iovec->bstat (abfd, &buf) != 0)
    return 0;

  abfd->mtime = buf.st_mtime;             /* Save value in case anyone wants it */
  return buf.st_mtime;
}

Here is the caller graph for this function:

file_ptr bfd_get_size ( bfd abfd)

Definition at line 442 of file bfdio.c.

{
  struct stat buf;

  if ((abfd->flags & BFD_IN_MEMORY) != 0)
    return ((struct bfd_in_memory *) abfd->iostream)->size;

  if (abfd->iovec == NULL)
    return 0;

  if (abfd->iovec->bstat (abfd, &buf) != 0)
    return 0;

  return buf.st_size;
}
int bfd_seek ( bfd abfd,
file_ptr  position,
int  direction 
)

Definition at line 265 of file bfdio.c.

{
  int result;
  file_ptr file_position;
  /* For the time being, a BFD may not seek to it's end.  The problem
     is that we don't easily have a way to recognize the end of an
     element in an archive.  */

  BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);

  if (direction == SEEK_CUR && position == 0)
    return 0;

  if ((abfd->flags & BFD_IN_MEMORY) != 0)
    {
      struct bfd_in_memory *bim;

      bim = abfd->iostream;

      if (direction == SEEK_SET)
       abfd->where = position;
      else
       abfd->where += position;

      if (abfd->where > bim->size)
       {
         if ((abfd->direction == write_direction) ||
             (abfd->direction == both_direction))
           {
             bfd_size_type newsize, oldsize;

             oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
             bim->size = abfd->where;
             /* Round up to cut down on memory fragmentation */
             newsize = (bim->size + 127) & ~(bfd_size_type) 127;
             if (newsize > oldsize)
               {
                bim->buffer = bfd_realloc (bim->buffer, newsize);
                if (bim->buffer == 0)
                  {
                    bim->size = 0;
                    return -1;
                  }
               }
           }
         else
           {
             abfd->where = bim->size;
             bfd_set_error (bfd_error_file_truncated);
             return -1;
           }
       }
      return 0;
    }

  if (abfd->format != bfd_archive && abfd->my_archive == 0)
    {
      if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
       return 0;
    }
  else
    {
      /* We need something smarter to optimize access to archives.
        Currently, anything inside an archive is read via the file
        handle for the archive.  Which means that a bfd_seek on one
        component affects the `current position' in the archive, as
        well as in any other component.

        It might be sufficient to put a spike through the cache
        abstraction, and look to the archive for the file position,
        but I think we should try for something cleaner.

        In the meantime, no optimization for archives.  */
    }

  file_position = position;
  if (direction == SEEK_SET && abfd->my_archive != NULL)
    file_position += abfd->origin;

  if (abfd->iovec)
    result = abfd->iovec->bseek (abfd, file_position, direction);
  else
    result = -1;

  if (result != 0)
    {
      int hold_errno = errno;

      /* Force redetermination of `where' field.  */
      bfd_tell (abfd);

      /* An EINVAL error probably means that the file offset was
         absurd.  */
      if (hold_errno == EINVAL)
       bfd_set_error (bfd_error_file_truncated);
      else
       {
         bfd_set_error (bfd_error_system_call);
         errno = hold_errno;
       }
    }
  else
    {
      /* Adjust `where' field.  */
      if (direction == SEEK_SET)
       abfd->where = position;
      else
       abfd->where += position;
    }
  return result;
}

Here is the call graph for this function:

int bfd_stat ( bfd abfd,
struct stat statbuf 
)

Definition at line 244 of file bfdio.c.

{
  int result;

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

  if (abfd->iovec)
    result = abfd->iovec->bstat (abfd, statbuf);
  else
    result = -1;

  if (result < 0)
    bfd_set_error (bfd_error_system_call);
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_ptr bfd_tell ( bfd abfd)

Definition at line 209 of file bfdio.c.

{
  file_ptr ptr;

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

  if (abfd->iovec)
    {
      ptr = abfd->iovec->btell (abfd);

      if (abfd->my_archive)
       ptr -= abfd->origin;
    }
  else
    ptr = 0;

  abfd->where = ptr;
  return ptr;
}

Here is the caller graph for this function:

FILE* real_fopen ( const char *  filename,
const char *  modes 
)

Definition at line 67 of file bfdio.c.

{
#if defined (HAVE_FOPEN64)
  return fopen64 (filename, modes);
#else
  return fopen (filename, modes);
#endif
}

Here is the caller graph for this function:

int real_fseek ( FILE *  file,
file_ptr  offset,
int  whence 
)

Definition at line 55 of file bfdio.c.

{
#if defined (HAVE_FSEEKO64)
  return fseeko64 (file, offset, whence);
#elif defined (HAVE_FSEEKO)
  return fseeko (file, offset, whence);
#else
  return fseek (file, offset, whence);
#endif
}

Here is the caller graph for this function:

file_ptr real_ftell ( FILE *  file)

Definition at line 43 of file bfdio.c.

{
#if defined (HAVE_FTELLO64)
  return ftello64 (file);
#elif defined (HAVE_FTELLO)
  return ftello (file);
#else
  return ftell (file);
#endif
}

Here is the caller graph for this function: