[deliverable/binutils-gdb.git] / bfd / bfdio.c

/* Low-level I/O routines for BFDs.
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   2000, 2001, 2002, 2003 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "sysdep.h"

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

#include <limits.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

/* Note that archive entries don't have streams; they share their parent's.
   This allows someone to play with the iostream behind BFD's back.

   Also, note that the origin pointer points to the beginning of a file's
   contents (0 for non-archive elements).  For archive entries this is the
   first octet in the file, NOT the beginning of the archive header.  */

static size_t
real_read (void *where, size_t a, size_t b, FILE *file)
{
  /* FIXME - this looks like an optimization, but it's really to cover
     up for a feature of some OSs (not solaris - sigh) that
     ld/pe-dll.c takes advantage of (apparently) when it creates BFDs
     internally and tries to link against them.  BFD seems to be smart
     enough to realize there are no symbol records in the "file" that
     doesn't exist but attempts to read them anyway.  On Solaris,
     attempting to read zero bytes from a NULL file results in a core
     dump, but on other platforms it just returns zero bytes read.
     This makes it to something reasonable. - DJ */
  if (a == 0 || b == 0)
    return 0;


#if defined (__VAX) && defined (VMS)
  /* Apparently fread on Vax VMS does not keep the record length
     information.  */
  return read (fileno (file), where, a * b);
#else
  return fread (where, a, b, file);
#endif
}

/* Return value is amount read.  */

bfd_size_type
bfd_bread (void *ptr, bfd_size_type size, bfd *abfd)
{
  size_t nread;

  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;
    }

  nread = real_read (ptr, 1, (size_t) size, bfd_cache_lookup (abfd));
  if (nread != (size_t) -1)
    abfd->where += nread;

  /* Set bfd_error if we did not read as much data as we expected.

     If the read failed due to an error set the bfd_error_system_call,
     else set bfd_error_file_truncated.

     A BFD backend may wish to override bfd_error_file_truncated to
     provide something more useful (eg. no_symbols or wrong_format).  */
  if (nread != size)
    {
      if (ferror (bfd_cache_lookup (abfd)))
	bfd_set_error (bfd_error_system_call);
      else
	bfd_set_error (bfd_error_file_truncated);
    }

  return nread;
}

bfd_size_type
bfd_bwrite (const void *ptr, bfd_size_type size, bfd *abfd)
{
  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;
    }

  nwrote = fwrite (ptr, 1, (size_t) size, bfd_cache_lookup (abfd));
  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;
}

bfd_vma
bfd_tell (bfd *abfd)
{
  file_ptr ptr;

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

  ptr = ftell (bfd_cache_lookup (abfd));

  if (abfd->my_archive)
    ptr -= abfd->origin;
  abfd->where = ptr;
  return ptr;
}

int
bfd_flush (bfd *abfd)
{
  if ((abfd->flags & BFD_IN_MEMORY) != 0)
    return 0;
  return fflush (bfd_cache_lookup(abfd));
}

/* Returns 0 for success, negative value for failure (in which case
   bfd_get_error can retrieve the error code).  */
int
bfd_stat (bfd *abfd, struct stat *statbuf)
{
  FILE *f;
  int result;

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

  f = bfd_cache_lookup (abfd);
  if (f == NULL)
    {
      bfd_set_error (bfd_error_system_call);
      return -1;
    }
  result = fstat (fileno (f), statbuf);
  if (result < 0)
    bfd_set_error (bfd_error_system_call);
  return result;
}

/* Returns 0 for success, nonzero for failure (in which case bfd_get_error
   can retrieve the error code).  */

int
bfd_seek (bfd *abfd, file_ptr position, int direction)
{
  int result;
  FILE *f;
  long 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 0
      /* Explanation for this code: I'm only about 95+% sure that the above
	 conditions are sufficient and that all i/o calls are properly
	 adjusting the `where' field.  So this is sort of an `assert'
	 that the `where' field is correct.  If we can go a while without
	 tripping the abort, we can probably safely disable this code,
	 so that the real optimizations happen.  */
      file_ptr where_am_i_now;
      where_am_i_now = ftell (bfd_cache_lookup (abfd));
      if (abfd->my_archive)
	where_am_i_now -= abfd->origin;
      if (where_am_i_now != abfd->where)
	abort ();
#endif
      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.  */
    }

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

  result = fseek (f, file_position, direction);
  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;
}

/*
FUNCTION
	bfd_get_mtime

SYNOPSIS
	long bfd_get_mtime (bfd *abfd);

DESCRIPTION
	Return the file modification time (as read from the file system, or
	from the archive header for archive members).

*/

long
bfd_get_mtime (bfd *abfd)
{
  FILE *fp;
  struct stat buf;

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

  fp = bfd_cache_lookup (abfd);
  if (0 != fstat (fileno (fp), &buf))
    return 0;

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

/*
FUNCTION
	bfd_get_size

SYNOPSIS
	long bfd_get_size (bfd *abfd);

DESCRIPTION
	Return the file size (as read from file system) for the file
	associated with BFD @var{abfd}.

	The initial motivation for, and use of, this routine is not
	so we can get the exact size of the object the BFD applies to, since
	that might not be generally possible (archive members for example).
	It would be ideal if someone could eventually modify
	it so that such results were guaranteed.

	Instead, we want to ask questions like "is this NNN byte sized
	object I'm about to try read from file offset YYY reasonable?"
	As as example of where we might do this, some object formats
	use string tables for which the first <<sizeof (long)>> bytes of the
	table contain the size of the table itself, including the size bytes.
	If an application tries to read what it thinks is one of these
	string tables, without some way to validate the size, and for
	some reason the size is wrong (byte swapping error, wrong location
	for the string table, etc.), the only clue is likely to be a read
	error when it tries to read the table, or a "virtual memory
	exhausted" error when it tries to allocate 15 bazillon bytes
	of space for the 15 bazillon byte table it is about to read.
	This function at least allows us to answer the question, "is the
	size reasonable?".
*/

long
bfd_get_size (bfd *abfd)
{
  FILE *fp;
  struct stat buf;

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

  fp = bfd_cache_lookup (abfd);
  if (0 != fstat (fileno (fp), & buf))
    return 0;

  return buf.st_size;
}
Commit	Line	Data
93509525 KD	1	/* Low-level I/O routines for BFDs.
93509525 KD	2	Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
eac93a98	3	2000, 2001, 2002, 2003 Free Software Foundation, Inc.
93509525 KD	4	Written by Cygnus Support.
	5
	6	This file is part of BFD, the Binary File Descriptor library.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	21
	22	#include "sysdep.h"
	23
	24	#include "bfd.h"
	25	#include "libbfd.h"
	26
	27	#include <limits.h>
	28
	29	#ifndef S_IXUSR
	30	#define S_IXUSR 0100 /* Execute by owner. */
	31	#endif
	32	#ifndef S_IXGRP
	33	#define S_IXGRP 0010 /* Execute by group. */
	34	#endif
	35	#ifndef S_IXOTH
	36	#define S_IXOTH 0001 /* Execute by others. */
	37	#endif
	38
	39	/* Note that archive entries don't have streams; they share their parent's.
	40	This allows someone to play with the iostream behind BFD's back.
	41
	42	Also, note that the origin pointer points to the beginning of a file's
	43	contents (0 for non-archive elements). For archive entries this is the
	44	first octet in the file, NOT the beginning of the archive header. */
	45
93509525	46	static size_t
c58b9523	47	real_read (void where, size_t a, size_t b, FILE file)
93509525 KD	48	{
	49	/* FIXME - this looks like an optimization, but it's really to cover
	50	up for a feature of some OSs (not solaris - sigh) that
	51	ld/pe-dll.c takes advantage of (apparently) when it creates BFDs
	52	internally and tries to link against them. BFD seems to be smart
	53	enough to realize there are no symbol records in the "file" that
	54	doesn't exist but attempts to read them anyway. On Solaris,
	55	attempting to read zero bytes from a NULL file results in a core
	56	dump, but on other platforms it just returns zero bytes read.
	57	This makes it to something reasonable. - DJ */
	58	if (a == 0 \|\| b == 0)
	59	return 0;
	60
	61
	62	#if defined (__VAX) && defined (VMS)
	63	/* Apparently fread on Vax VMS does not keep the record length
	64	information. */
	65	return read (fileno (file), where, a * b);
	66	#else
	67	return fread (where, a, b, file);
	68	#endif
	69	}
	70
	71	/* Return value is amount read. */
	72
	73	bfd_size_type
c58b9523	74	bfd_bread (void ptr, bfd_size_type size, bfd abfd)
93509525 KD	75	{
	76	size_t nread;
	77
	78	if ((abfd->flags & BFD_IN_MEMORY) != 0)
	79	{
	80	struct bfd_in_memory *bim;
	81	bfd_size_type get;
	82
c58b9523	83	bim = abfd->iostream;
93509525 KD	84	get = size;
	85	if (abfd->where + get > bim->size)
	86	{
	87	if (bim->size < (bfd_size_type) abfd->where)
	88	get = 0;
	89	else
	90	get = bim->size - abfd->where;
	91	bfd_set_error (bfd_error_file_truncated);
	92	}
	93	memcpy (ptr, bim->buffer + abfd->where, (size_t) get);
	94	abfd->where += get;
	95	return get;
	96	}
	97
	98	nread = real_read (ptr, 1, (size_t) size, bfd_cache_lookup (abfd));
	99	if (nread != (size_t) -1)
	100	abfd->where += nread;
	101
	102	/* Set bfd_error if we did not read as much data as we expected.
	103
	104	If the read failed due to an error set the bfd_error_system_call,
	105	else set bfd_error_file_truncated.
	106
	107	A BFD backend may wish to override bfd_error_file_truncated to
	108	provide something more useful (eg. no_symbols or wrong_format). */
	109	if (nread != size)
	110	{
	111	if (ferror (bfd_cache_lookup (abfd)))
	112	bfd_set_error (bfd_error_system_call);
	113	else
	114	bfd_set_error (bfd_error_file_truncated);
	115	}
	116
	117	return nread;
	118	}
	119
	120	bfd_size_type
c58b9523	121	bfd_bwrite (const void ptr, bfd_size_type size, bfd abfd)
93509525 KD	122	{
	123	size_t nwrote;
	124
	125	if ((abfd->flags & BFD_IN_MEMORY) != 0)
	126	{
c58b9523	127	struct bfd_in_memory *bim = abfd->iostream;
93509525 KD	128	size = (size_t) size;
	129	if (abfd->where + size > bim->size)
	130	{
	131	bfd_size_type newsize, oldsize;
	132
	133	oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
	134	bim->size = abfd->where + size;
	135	/* Round up to cut down on memory fragmentation */
	136	newsize = (bim->size + 127) & ~(bfd_size_type) 127;
	137	if (newsize > oldsize)
	138	{
c58b9523	139	bim->buffer = bfd_realloc (bim->buffer, newsize);
93509525 KD	140	if (bim->buffer == 0)
	141	{
	142	bim->size = 0;
	143	return 0;
	144	}
	145	}
	146	}
	147	memcpy (bim->buffer + abfd->where, ptr, (size_t) size);
	148	abfd->where += size;
	149	return size;
	150	}
	151
	152	nwrote = fwrite (ptr, 1, (size_t) size, bfd_cache_lookup (abfd));
	153	if (nwrote != (size_t) -1)
	154	abfd->where += nwrote;
	155	if (nwrote != size)
	156	{
	157	#ifdef ENOSPC
	158	errno = ENOSPC;
	159	#endif
	160	bfd_set_error (bfd_error_system_call);
	161	}
	162	return nwrote;
	163	}
	164
	165	bfd_vma
c58b9523	166	bfd_tell (bfd *abfd)
93509525 KD	167	{
	168	file_ptr ptr;
	169
	170	if ((abfd->flags & BFD_IN_MEMORY) != 0)
	171	return abfd->where;
	172
	173	ptr = ftell (bfd_cache_lookup (abfd));
	174
	175	if (abfd->my_archive)
	176	ptr -= abfd->origin;
	177	abfd->where = ptr;
	178	return ptr;
	179	}
	180
	181	int
c58b9523	182	bfd_flush (bfd *abfd)
93509525 KD	183	{
	184	if ((abfd->flags & BFD_IN_MEMORY) != 0)
	185	return 0;
	186	return fflush (bfd_cache_lookup(abfd));
	187	}
	188
	189	/* Returns 0 for success, negative value for failure (in which case
	190	bfd_get_error can retrieve the error code). */
	191	int
c58b9523	192	bfd_stat (bfd abfd, struct stat statbuf)
93509525 KD	193	{
	194	FILE *f;
	195	int result;
	196
	197	if ((abfd->flags & BFD_IN_MEMORY) != 0)
	198	abort ();
	199
	200	f = bfd_cache_lookup (abfd);
	201	if (f == NULL)
	202	{
	203	bfd_set_error (bfd_error_system_call);
	204	return -1;
	205	}
	206	result = fstat (fileno (f), statbuf);
	207	if (result < 0)
	208	bfd_set_error (bfd_error_system_call);
	209	return result;
	210	}
	211
	212	/* Returns 0 for success, nonzero for failure (in which case bfd_get_error
	213	can retrieve the error code). */
	214
	215	int
c58b9523	216	bfd_seek (bfd *abfd, file_ptr position, int direction)
93509525 KD	217	{
	218	int result;
	219	FILE *f;
	220	long file_position;
	221	/* For the time being, a BFD may not seek to it's end. The problem
	222	is that we don't easily have a way to recognize the end of an
	223	element in an archive. */
	224
	225	BFD_ASSERT (direction == SEEK_SET \|\| direction == SEEK_CUR);
	226
	227	if (direction == SEEK_CUR && position == 0)
	228	return 0;
	229
	230	if ((abfd->flags & BFD_IN_MEMORY) != 0)
	231	{
	232	struct bfd_in_memory *bim;
	233
c58b9523	234	bim = abfd->iostream;
93509525 KD	235
	236	if (direction == SEEK_SET)
	237	abfd->where = position;
	238	else
	239	abfd->where += position;
	240
	241	if (abfd->where > bim->size)
	242	{
	243	if ((abfd->direction == write_direction) \|\|
	244	(abfd->direction == both_direction))
	245	{
	246	bfd_size_type newsize, oldsize;
	247	oldsize = (bim->size + 127) & ~(bfd_size_type) 127;
	248	bim->size = abfd->where;
	249	/* Round up to cut down on memory fragmentation */
	250	newsize = (bim->size + 127) & ~(bfd_size_type) 127;
	251	if (newsize > oldsize)
	252	{
c58b9523	253	bim->buffer = bfd_realloc (bim->buffer, newsize);
93509525 KD	254	if (bim->buffer == 0)
	255	{
	256	bim->size = 0;
	257	return -1;
	258	}
	259	}
	260	}
	261	else
	262	{
	263	abfd->where = bim->size;
	264	bfd_set_error (bfd_error_file_truncated);
	265	return -1;
	266	}
	267	}
	268	return 0;
	269	}
	270
	271	if (abfd->format != bfd_archive && abfd->my_archive == 0)
	272	{
	273	#if 0
	274	/* Explanation for this code: I'm only about 95+% sure that the above
	275	conditions are sufficient and that all i/o calls are properly
	276	adjusting the `where' field. So this is sort of an `assert'
	277	that the `where' field is correct. If we can go a while without
	278	tripping the abort, we can probably safely disable this code,
	279	so that the real optimizations happen. */
	280	file_ptr where_am_i_now;
	281	where_am_i_now = ftell (bfd_cache_lookup (abfd));
	282	if (abfd->my_archive)
	283	where_am_i_now -= abfd->origin;
	284	if (where_am_i_now != abfd->where)
	285	abort ();
	286	#endif
	287	if (direction == SEEK_SET && (bfd_vma) position == abfd->where)
	288	return 0;
	289	}
	290	else
	291	{
	292	/* We need something smarter to optimize access to archives.
	293	Currently, anything inside an archive is read via the file
	294	handle for the archive. Which means that a bfd_seek on one
	295	component affects the `current position' in the archive, as
	296	well as in any other component.
	297
	298	It might be sufficient to put a spike through the cache
	299	abstraction, and look to the archive for the file position,
	300	but I think we should try for something cleaner.
	301
	302	In the meantime, no optimization for archives. */
	303	}
	304
	305	f = bfd_cache_lookup (abfd);
	306	file_position = position;
	307	if (direction == SEEK_SET && abfd->my_archive != NULL)
	308	file_position += abfd->origin;
	309
	310	result = fseek (f, file_position, direction);
	311	if (result != 0)
	312	{
	313	int hold_errno = errno;
	314
	315	/* Force redetermination of `where' field. */
	316	bfd_tell (abfd);
	317
318	/* An EINVAL error probably means that the file offset was
319	absurd. */
320	if (hold_errno == EINVAL)
321	bfd_set_error (bfd_error_file_truncated);
322	else
323	{
324	bfd_set_error (bfd_error_system_call);
325	errno = hold_errno;
326	}
327	}
328	else
329	{
330	/* Adjust `where' field. */
331	if (direction == SEEK_SET)
332	abfd->where = position;
333	else
334	abfd->where += position;
335	}
336	return result;
337	}
338
339	/*
340	FUNCTION
341	bfd_get_mtime
342
343	SYNOPSIS
c58b9523	344	long bfd_get_mtime (bfd *abfd);
93509525 KD	345
	346	DESCRIPTION
	347	Return the file modification time (as read from the file system, or
	348	from the archive header for archive members).
	349
	350	*/
	351
	352	long
c58b9523	353	bfd_get_mtime (bfd *abfd)
93509525 KD	354	{
	355	FILE *fp;
	356	struct stat buf;
	357
	358	if (abfd->mtime_set)
	359	return abfd->mtime;
	360
	361	fp = bfd_cache_lookup (abfd);
	362	if (0 != fstat (fileno (fp), &buf))
	363	return 0;
	364
	365	abfd->mtime = buf.st_mtime; /* Save value in case anyone wants it */
	366	return buf.st_mtime;
	367	}
	368
	369	/*
	370	FUNCTION
	371	bfd_get_size
	372
	373	SYNOPSIS
c58b9523	374	long bfd_get_size (bfd *abfd);
93509525 KD	375
	376	DESCRIPTION
	377	Return the file size (as read from file system) for the file
	378	associated with BFD @var{abfd}.
	379
	380	The initial motivation for, and use of, this routine is not
	381	so we can get the exact size of the object the BFD applies to, since
	382	that might not be generally possible (archive members for example).
	383	It would be ideal if someone could eventually modify
	384	it so that such results were guaranteed.
	385
	386	Instead, we want to ask questions like "is this NNN byte sized
	387	object I'm about to try read from file offset YYY reasonable?"
	388	As as example of where we might do this, some object formats
	389	use string tables for which the first <<sizeof (long)>> bytes of the
	390	table contain the size of the table itself, including the size bytes.
	391	If an application tries to read what it thinks is one of these
	392	string tables, without some way to validate the size, and for
	393	some reason the size is wrong (byte swapping error, wrong location
	394	for the string table, etc.), the only clue is likely to be a read
	395	error when it tries to read the table, or a "virtual memory
	396	exhausted" error when it tries to allocate 15 bazillon bytes
	397	of space for the 15 bazillon byte table it is about to read.
5c4491d3	398	This function at least allows us to answer the question, "is the
93509525 KD	399	size reasonable?".
	400	*/
	401
	402	long
c58b9523	403	bfd_get_size (bfd *abfd)
93509525 KD	404	{
	405	FILE *fp;
	406	struct stat buf;
	407
	408	if ((abfd->flags & BFD_IN_MEMORY) != 0)
	409	return ((struct bfd_in_memory *) abfd->iostream)->size;
	410
	411	fp = bfd_cache_lookup (abfd);
	412	if (0 != fstat (fileno (fp), & buf))
	413	return 0;
	414
	415	return buf.st_size;
	416	}