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

/* BFD library -- caching of file descriptors.

   Copyright 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002,
   2003, 2004 Free Software Foundation, Inc.

   Hacked by Steve Chamberlain of Cygnus Support (steve@cygnus.com).

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

/*
SECTION
	File caching

	The file caching mechanism is embedded within BFD and allows
	the application to open as many BFDs as it wants without
	regard to the underlying operating system's file descriptor
	limit (often as low as 20 open files).  The module in
	<<cache.c>> maintains a least recently used list of
	<<BFD_CACHE_MAX_OPEN>> files, and exports the name
	<<bfd_cache_lookup>>, which runs around and makes sure that
	the required BFD is open. If not, then it chooses a file to
	close, closes it and opens the one wanted, returning its file
	handle.

*/

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

static bfd_boolean bfd_cache_delete (bfd *);


static file_ptr
cache_btell (struct bfd *abfd)
{
  return real_ftell (bfd_cache_lookup (abfd));
}

static int
cache_bseek (struct bfd *abfd, file_ptr offset, int whence)
{
  return real_fseek (bfd_cache_lookup (abfd), offset, whence);
}

/* 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 file_ptr
cache_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
{
  file_ptr nread;
  /* 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 (nbytes == 0)
    return 0;

#if defined (__VAX) && defined (VMS)
  /* Apparently fread on Vax VMS does not keep the record length
     information.  */
  nread = read (fileno (bfd_cache_lookup (abfd)), buf, nbytes);
  /* 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.  */
  if (nread == (file_ptr)-1)
    {
      bfd_set_error (bfd_error_system_call);
      return -1;
    }
#else
  nread = fread (buf, 1, nbytes, bfd_cache_lookup (abfd));
  /* 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.  */
  if (nread < nbytes && ferror (bfd_cache_lookup (abfd)))
    {
      bfd_set_error (bfd_error_system_call);
      return -1;
    }
#endif
  return nread;
}

static file_ptr
cache_bwrite (struct bfd *abfd, const void *where, file_ptr nbytes)
{
  file_ptr nwrite = fwrite (where, 1, nbytes, bfd_cache_lookup (abfd));
  if (nwrite < nbytes && ferror (bfd_cache_lookup (abfd)))
    {
      bfd_set_error (bfd_error_system_call);
      return -1;
    }
  return nwrite;
}

static int
cache_bclose (struct bfd *abfd)
{
  return bfd_cache_close (abfd);
}

static int
cache_bflush (struct bfd *abfd)
{
  int sts = fflush (bfd_cache_lookup (abfd));
  if (sts < 0)
    bfd_set_error (bfd_error_system_call);
  return sts;
}

static int
cache_bstat (struct bfd *abfd, struct stat *sb)
{
  int sts = fstat (fileno (bfd_cache_lookup (abfd)), sb);
  if (sts < 0)
    bfd_set_error (bfd_error_system_call);
  return sts;
}

static const struct bfd_iovec cache_iovec = {
  &cache_bread, &cache_bwrite, &cache_btell, &cache_bseek,
  &cache_bclose, &cache_bflush, &cache_bstat
};

/*
INTERNAL_FUNCTION
	BFD_CACHE_MAX_OPEN macro

DESCRIPTION
	The maximum number of files which the cache will keep open at
	one time.

.#define BFD_CACHE_MAX_OPEN 10

*/

/* The number of BFD files we have open.  */

static int open_files;

/*
INTERNAL_FUNCTION
	bfd_last_cache

SYNOPSIS
	extern bfd *bfd_last_cache;

DESCRIPTION
	Zero, or a pointer to the topmost BFD on the chain.  This is
	used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
	determine when it can avoid a function call.
*/

bfd *bfd_last_cache;

/*
  INTERNAL_FUNCTION
  	bfd_cache_lookup

  DESCRIPTION
 	Check to see if the required BFD is the same as the last one
 	looked up. If so, then it can use the stream in the BFD with
 	impunity, since it can't have changed since the last lookup;
 	otherwise, it has to perform the complicated lookup function.

  .#define bfd_cache_lookup(x) \
  .    ((x) == bfd_last_cache ? \
  .      (FILE *) (bfd_last_cache->iostream): \
  .       bfd_cache_lookup_worker (x))

 */

/* Insert a BFD into the cache.  */

static void
insert (bfd *abfd)
{
  if (bfd_last_cache == NULL)
    {
      abfd->lru_next = abfd;
      abfd->lru_prev = abfd;
    }
  else
    {
      abfd->lru_next = bfd_last_cache;
      abfd->lru_prev = bfd_last_cache->lru_prev;
      abfd->lru_prev->lru_next = abfd;
      abfd->lru_next->lru_prev = abfd;
    }
  bfd_last_cache = abfd;
}

/* Remove a BFD from the cache.  */

static void
snip (bfd *abfd)
{
  abfd->lru_prev->lru_next = abfd->lru_next;
  abfd->lru_next->lru_prev = abfd->lru_prev;
  if (abfd == bfd_last_cache)
    {
      bfd_last_cache = abfd->lru_next;
      if (abfd == bfd_last_cache)
	bfd_last_cache = NULL;
    }
}

/* We need to open a new file, and the cache is full.  Find the least
   recently used cacheable BFD and close it.  */

static bfd_boolean
close_one (void)
{
  register bfd *kill;

  if (bfd_last_cache == NULL)
    kill = NULL;
  else
    {
      for (kill = bfd_last_cache->lru_prev;
	   ! kill->cacheable;
	   kill = kill->lru_prev)
	{
	  if (kill == bfd_last_cache)
	    {
	      kill = NULL;
	      break;
	    }
	}
    }

  if (kill == NULL)
    {
      /* There are no open cacheable BFD's.  */
      return TRUE;
    }

  kill->where = real_ftell ((FILE *) kill->iostream);

  return bfd_cache_delete (kill);
}

/* Close a BFD and remove it from the cache.  */

static bfd_boolean
bfd_cache_delete (bfd *abfd)
{
  bfd_boolean ret;

  if (fclose ((FILE *) abfd->iostream) == 0)
    ret = TRUE;
  else
    {
      ret = FALSE;
      bfd_set_error (bfd_error_system_call);
    }

  snip (abfd);

  abfd->iostream = NULL;
  --open_files;

  return ret;
}

/*
INTERNAL_FUNCTION
	bfd_cache_init

SYNOPSIS
	bfd_boolean bfd_cache_init (bfd *abfd);

DESCRIPTION
	Add a newly opened BFD to the cache.
*/

bfd_boolean
bfd_cache_init (bfd *abfd)
{
  BFD_ASSERT (abfd->iostream != NULL);
  if (open_files >= BFD_CACHE_MAX_OPEN)
    {
      if (! close_one ())
	return FALSE;
    }
  abfd->iovec = &cache_iovec;
  insert (abfd);
  ++open_files;
  return TRUE;
}

/*
INTERNAL_FUNCTION
	bfd_cache_close

SYNOPSIS
	bfd_boolean bfd_cache_close (bfd *abfd);

DESCRIPTION
	Remove the BFD @var{abfd} from the cache. If the attached file is open,
	then close it too.

RETURNS
	<<FALSE>> is returned if closing the file fails, <<TRUE>> is
	returned if all is well.
*/

bfd_boolean
bfd_cache_close (bfd *abfd)
{
  if (abfd->iovec != &cache_iovec)
    return TRUE;

  if (abfd->iostream == NULL)
    /* Previously closed.  */
    return TRUE;

  return bfd_cache_delete (abfd);
}

/*
FUNCTION
	bfd_cache_close_all

SYNOPSIS
	bfd_boolean bfd_cache_close_all (void);

DESCRIPTION
	Remove all BFDs from the cache. If the attached file is open,
	then close it too.

RETURNS
	<<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
	returned if all is well.
*/

bfd_boolean
bfd_cache_close_all ()
{
  bfd_boolean ret = TRUE;

  while (bfd_last_cache != NULL)
    ret &= bfd_cache_close (bfd_last_cache);

  return ret;
}

/*
INTERNAL_FUNCTION
	bfd_open_file

SYNOPSIS
	FILE* bfd_open_file (bfd *abfd);

DESCRIPTION
	Call the OS to open a file for @var{abfd}.  Return the <<FILE *>>
	(possibly <<NULL>>) that results from this operation.  Set up the
	BFD so that future accesses know the file is open. If the <<FILE *>>
	returned is <<NULL>>, then it won't have been put in the
	cache, so it won't have to be removed from it.
*/

FILE *
bfd_open_file (bfd *abfd)
{
  abfd->cacheable = TRUE;	/* Allow it to be closed later.  */

  if (open_files >= BFD_CACHE_MAX_OPEN)
    {
      if (! close_one ())
	return NULL;
    }

  switch (abfd->direction)
    {
    case read_direction:
    case no_direction:
      abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RB);
      break;
    case both_direction:
    case write_direction:
      if (abfd->opened_once)
	{
	  abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RUB);
	  if (abfd->iostream == NULL)
	    abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
	}
      else
	{
	  /* Create the file.

	     Some operating systems won't let us overwrite a running
	     binary.  For them, we want to unlink the file first.

	     However, gcc 2.95 will create temporary files using
	     O_EXCL and tight permissions to prevent other users from
	     substituting other .o files during the compilation.  gcc
	     will then tell the assembler to use the newly created
	     file as an output file.  If we unlink the file here, we
	     open a brief window when another user could still
	     substitute a file.

	     So we unlink the output file if and only if it has
	     non-zero size.  */
#ifndef __MSDOS__
	  /* Don't do this for MSDOS: it doesn't care about overwriting
	     a running binary, but if this file is already open by
	     another BFD, we will be in deep trouble if we delete an
	     open file.  In fact, objdump does just that if invoked with
	     the --info option.  */
	  struct stat s;

	  if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
	    unlink (abfd->filename);
#endif
	  abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
	  abfd->opened_once = TRUE;
	}
      break;
    }

  if (abfd->iostream != NULL)
    {
      if (! bfd_cache_init (abfd))
	return NULL;
    }

  return (FILE *) abfd->iostream;
}

/*
INTERNAL_FUNCTION
	bfd_cache_lookup_worker

SYNOPSIS
	FILE *bfd_cache_lookup_worker (bfd *abfd);

DESCRIPTION
	Called when the macro <<bfd_cache_lookup>> fails to find a
	quick answer.  Find a file descriptor for @var{abfd}.  If
	necessary, it open it.  If there are already more than
	<<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
	avoid running out of file descriptors.  It will abort rather than
	returning NULL if it is unable to (re)open the @var{abfd}.
*/

FILE *
bfd_cache_lookup_worker (bfd *abfd)
{
  if ((abfd->flags & BFD_IN_MEMORY) != 0)
    abort ();

  if (abfd->my_archive)
    abfd = abfd->my_archive;

  if (abfd->iostream != NULL)
    {
      /* Move the file to the start of the cache.  */
      if (abfd != bfd_last_cache)
	{
	  snip (abfd);
	  insert (abfd);
	}
    }
  else
    {
      if (bfd_open_file (abfd) == NULL
	  || abfd->where != (unsigned long) abfd->where
	  || real_fseek ((FILE *) abfd->iostream, abfd->where, SEEK_SET) != 0)
	abort ();
    }

  return (FILE *) abfd->iostream;
}
Commit	Line	Data
	1	/* BFD library -- caching of file descriptors.
	2
	3	Copyright 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002,
	4	2003, 2004 Free Software Foundation, Inc.
	5
	6	Hacked by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
	7
	8	This file is part of BFD, the Binary File Descriptor library.
	9
	10	This program is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License as published by
	12	the Free Software Foundation; either version 2 of the License, or
	13	(at your option) any later version.
	14
	15	This program is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
	19
	20	You should have received a copy of the GNU General Public License
	21	along with this program; if not, write to the Free Software
	22	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	23
	24	/*
	25	SECTION
	26	File caching
	27
	28	The file caching mechanism is embedded within BFD and allows
	29	the application to open as many BFDs as it wants without
	30	regard to the underlying operating system's file descriptor
	31	limit (often as low as 20 open files). The module in
	32	<<cache.c>> maintains a least recently used list of
	33	<<BFD_CACHE_MAX_OPEN>> files, and exports the name
	34	<<bfd_cache_lookup>>, which runs around and makes sure that
	35	the required BFD is open. If not, then it chooses a file to
	36	close, closes it and opens the one wanted, returning its file
	37	handle.
	38
	39	*/
	40
	41	#include "bfd.h"
	42	#include "sysdep.h"
	43	#include "libbfd.h"
	44
	45	static bfd_boolean bfd_cache_delete (bfd *);
	46
	47
	48	static file_ptr
	49	cache_btell (struct bfd *abfd)
	50	{
	51	return real_ftell (bfd_cache_lookup (abfd));
	52	}
	53
	54	static int
	55	cache_bseek (struct bfd *abfd, file_ptr offset, int whence)
	56	{
	57	return real_fseek (bfd_cache_lookup (abfd), offset, whence);
	58	}
	59
	60	/* Note that archive entries don't have streams; they share their parent's.
	61	This allows someone to play with the iostream behind BFD's back.
	62
	63	Also, note that the origin pointer points to the beginning of a file's
	64	contents (0 for non-archive elements). For archive entries this is the
	65	first octet in the file, NOT the beginning of the archive header. */
	66
	67	static file_ptr
	68	cache_bread (struct bfd abfd, void buf, file_ptr nbytes)
	69	{
	70	file_ptr nread;
	71	/* FIXME - this looks like an optimization, but it's really to cover
	72	up for a feature of some OSs (not solaris - sigh) that
	73	ld/pe-dll.c takes advantage of (apparently) when it creates BFDs
	74	internally and tries to link against them. BFD seems to be smart
	75	enough to realize there are no symbol records in the "file" that
	76	doesn't exist but attempts to read them anyway. On Solaris,
	77	attempting to read zero bytes from a NULL file results in a core
	78	dump, but on other platforms it just returns zero bytes read.
	79	This makes it to something reasonable. - DJ */
	80	if (nbytes == 0)
	81	return 0;
	82
	83	#if defined (__VAX) && defined (VMS)
	84	/* Apparently fread on Vax VMS does not keep the record length
	85	information. */
	86	nread = read (fileno (bfd_cache_lookup (abfd)), buf, nbytes);
	87	/* Set bfd_error if we did not read as much data as we expected. If
	88	the read failed due to an error set the bfd_error_system_call,
	89	else set bfd_error_file_truncated. */
	90	if (nread == (file_ptr)-1)
	91	{
	92	bfd_set_error (bfd_error_system_call);
	93	return -1;
	94	}
	95	#else
	96	nread = fread (buf, 1, nbytes, bfd_cache_lookup (abfd));
	97	/* Set bfd_error if we did not read as much data as we expected. If
	98	the read failed due to an error set the bfd_error_system_call,
	99	else set bfd_error_file_truncated. */
	100	if (nread < nbytes && ferror (bfd_cache_lookup (abfd)))
	101	{
	102	bfd_set_error (bfd_error_system_call);
	103	return -1;
	104	}
	105	#endif
	106	return nread;
	107	}
	108
	109	static file_ptr
	110	cache_bwrite (struct bfd abfd, const void where, file_ptr nbytes)
	111	{
	112	file_ptr nwrite = fwrite (where, 1, nbytes, bfd_cache_lookup (abfd));
	113	if (nwrite < nbytes && ferror (bfd_cache_lookup (abfd)))
	114	{
	115	bfd_set_error (bfd_error_system_call);
	116	return -1;
	117	}
	118	return nwrite;
	119	}
	120
	121	static int
	122	cache_bclose (struct bfd *abfd)
	123	{
	124	return bfd_cache_close (abfd);
	125	}
	126
	127	static int
	128	cache_bflush (struct bfd *abfd)
	129	{
	130	int sts = fflush (bfd_cache_lookup (abfd));
	131	if (sts < 0)
	132	bfd_set_error (bfd_error_system_call);
	133	return sts;
	134	}
	135
	136	static int
	137	cache_bstat (struct bfd abfd, struct stat sb)
	138	{
	139	int sts = fstat (fileno (bfd_cache_lookup (abfd)), sb);
	140	if (sts < 0)
	141	bfd_set_error (bfd_error_system_call);
	142	return sts;
	143	}
	144
	145	static const struct bfd_iovec cache_iovec = {
	146	&cache_bread, &cache_bwrite, &cache_btell, &cache_bseek,
	147	&cache_bclose, &cache_bflush, &cache_bstat
	148	};
	149
	150	/*
	151	INTERNAL_FUNCTION
	152	BFD_CACHE_MAX_OPEN macro
	153
	154	DESCRIPTION
	155	The maximum number of files which the cache will keep open at
	156	one time.
	157
	158	.#define BFD_CACHE_MAX_OPEN 10
	159
	160	*/
	161
	162	/* The number of BFD files we have open. */
	163
	164	static int open_files;
	165
	166	/*
	167	INTERNAL_FUNCTION
	168	bfd_last_cache
	169
	170	SYNOPSIS
	171	extern bfd *bfd_last_cache;
	172
	173	DESCRIPTION
	174	Zero, or a pointer to the topmost BFD on the chain. This is
	175	used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
	176	determine when it can avoid a function call.
	177	*/
	178
	179	bfd *bfd_last_cache;
	180
	181	/*
	182	INTERNAL_FUNCTION
	183	bfd_cache_lookup
	184
	185	DESCRIPTION
	186	Check to see if the required BFD is the same as the last one
	187	looked up. If so, then it can use the stream in the BFD with
	188	impunity, since it can't have changed since the last lookup;
	189	otherwise, it has to perform the complicated lookup function.
	190
	191	.#define bfd_cache_lookup(x) \
	192	. ((x) == bfd_last_cache ? \
	193	. (FILE *) (bfd_last_cache->iostream): \
	194	. bfd_cache_lookup_worker (x))
	195
	196	*/
	197
	198	/* Insert a BFD into the cache. */
	199
	200	static void
	201	insert (bfd *abfd)
	202	{
	203	if (bfd_last_cache == NULL)
	204	{
	205	abfd->lru_next = abfd;
	206	abfd->lru_prev = abfd;
	207	}
	208	else
	209	{
	210	abfd->lru_next = bfd_last_cache;
	211	abfd->lru_prev = bfd_last_cache->lru_prev;
	212	abfd->lru_prev->lru_next = abfd;
	213	abfd->lru_next->lru_prev = abfd;
	214	}
	215	bfd_last_cache = abfd;
	216	}
	217
	218	/* Remove a BFD from the cache. */
	219
	220	static void
	221	snip (bfd *abfd)
	222	{
	223	abfd->lru_prev->lru_next = abfd->lru_next;
	224	abfd->lru_next->lru_prev = abfd->lru_prev;
	225	if (abfd == bfd_last_cache)
	226	{
	227	bfd_last_cache = abfd->lru_next;
	228	if (abfd == bfd_last_cache)
	229	bfd_last_cache = NULL;
	230	}
	231	}
	232
	233	/* We need to open a new file, and the cache is full. Find the least
	234	recently used cacheable BFD and close it. */
	235
	236	static bfd_boolean
	237	close_one (void)
	238	{
	239	register bfd *kill;
	240
	241	if (bfd_last_cache == NULL)
	242	kill = NULL;
	243	else
	244	{
	245	for (kill = bfd_last_cache->lru_prev;
	246	! kill->cacheable;
	247	kill = kill->lru_prev)
	248	{
	249	if (kill == bfd_last_cache)
	250	{
	251	kill = NULL;
	252	break;
	253	}
	254	}
	255	}
	256
	257	if (kill == NULL)
	258	{
	259	/* There are no open cacheable BFD's. */
	260	return TRUE;
	261	}
	262
	263	kill->where = real_ftell ((FILE *) kill->iostream);
	264
	265	return bfd_cache_delete (kill);
	266	}
	267
	268	/* Close a BFD and remove it from the cache. */
	269
	270	static bfd_boolean
	271	bfd_cache_delete (bfd *abfd)
	272	{
	273	bfd_boolean ret;
	274
	275	if (fclose ((FILE *) abfd->iostream) == 0)
	276	ret = TRUE;
	277	else
	278	{
	279	ret = FALSE;
	280	bfd_set_error (bfd_error_system_call);
	281	}
	282
	283	snip (abfd);
	284
	285	abfd->iostream = NULL;
	286	--open_files;
	287
	288	return ret;
	289	}
	290
	291	/*
	292	INTERNAL_FUNCTION
	293	bfd_cache_init
	294
	295	SYNOPSIS
	296	bfd_boolean bfd_cache_init (bfd *abfd);
	297
	298	DESCRIPTION
	299	Add a newly opened BFD to the cache.
	300	*/
	301
	302	bfd_boolean
	303	bfd_cache_init (bfd *abfd)
	304	{
	305	BFD_ASSERT (abfd->iostream != NULL);
	306	if (open_files >= BFD_CACHE_MAX_OPEN)
	307	{
	308	if (! close_one ())
	309	return FALSE;
	310	}
	311	abfd->iovec = &cache_iovec;
	312	insert (abfd);
	313	++open_files;
	314	return TRUE;
	315	}
	316
	317	/*
	318	INTERNAL_FUNCTION
	319	bfd_cache_close
	320
	321	SYNOPSIS
	322	bfd_boolean bfd_cache_close (bfd *abfd);
	323
	324	DESCRIPTION
	325	Remove the BFD @var{abfd} from the cache. If the attached file is open,
	326	then close it too.
	327
	328	RETURNS
	329	<<FALSE>> is returned if closing the file fails, <<TRUE>> is
	330	returned if all is well.
	331	*/
	332
	333	bfd_boolean
	334	bfd_cache_close (bfd *abfd)
	335	{
	336	if (abfd->iovec != &cache_iovec)
	337	return TRUE;
	338
	339	if (abfd->iostream == NULL)
	340	/* Previously closed. */
	341	return TRUE;
	342
	343	return bfd_cache_delete (abfd);
	344	}
	345
	346	/*
	347	FUNCTION
	348	bfd_cache_close_all
	349
	350	SYNOPSIS
	351	bfd_boolean bfd_cache_close_all (void);
	352
	353	DESCRIPTION
	354	Remove all BFDs from the cache. If the attached file is open,
	355	then close it too.
	356
	357	RETURNS
	358	<<FALSE>> is returned if closing one of the file fails, <<TRUE>> is
	359	returned if all is well.
	360	*/
	361
	362	bfd_boolean
	363	bfd_cache_close_all ()
	364	{
	365	bfd_boolean ret = TRUE;
	366
	367	while (bfd_last_cache != NULL)
	368	ret &= bfd_cache_close (bfd_last_cache);
	369
	370	return ret;
	371	}
	372
	373	/*
	374	INTERNAL_FUNCTION
	375	bfd_open_file
	376
	377	SYNOPSIS
	378	FILE* bfd_open_file (bfd *abfd);
	379
	380	DESCRIPTION
	381	Call the OS to open a file for @var{abfd}. Return the <<FILE *>>
	382	(possibly <<NULL>>) that results from this operation. Set up the
	383	BFD so that future accesses know the file is open. If the <<FILE *>>
	384	returned is <<NULL>>, then it won't have been put in the
	385	cache, so it won't have to be removed from it.
	386	*/
	387
	388	FILE *
	389	bfd_open_file (bfd *abfd)
	390	{
	391	abfd->cacheable = TRUE; /* Allow it to be closed later. */
	392
	393	if (open_files >= BFD_CACHE_MAX_OPEN)
	394	{
	395	if (! close_one ())
	396	return NULL;
	397	}
	398
	399	switch (abfd->direction)
	400	{
	401	case read_direction:
	402	case no_direction:
	403	abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RB);
	404	break;
	405	case both_direction:
	406	case write_direction:
	407	if (abfd->opened_once)
	408	{
	409	abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RUB);
	410	if (abfd->iostream == NULL)
	411	abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
	412	}
	413	else
	414	{
	415	/* Create the file.
	416
	417	Some operating systems won't let us overwrite a running
	418	binary. For them, we want to unlink the file first.
	419
	420	However, gcc 2.95 will create temporary files using
	421	O_EXCL and tight permissions to prevent other users from
	422	substituting other .o files during the compilation. gcc
	423	will then tell the assembler to use the newly created
	424	file as an output file. If we unlink the file here, we
	425	open a brief window when another user could still
	426	substitute a file.
	427
	428	So we unlink the output file if and only if it has
	429	non-zero size. */
	430	#ifndef __MSDOS__
	431	/* Don't do this for MSDOS: it doesn't care about overwriting
	432	a running binary, but if this file is already open by
	433	another BFD, we will be in deep trouble if we delete an
	434	open file. In fact, objdump does just that if invoked with
	435	the --info option. */
	436	struct stat s;
	437
	438	if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
	439	unlink (abfd->filename);
	440	#endif
	441	abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
	442	abfd->opened_once = TRUE;
	443	}
	444	break;
	445	}
	446
	447	if (abfd->iostream != NULL)
	448	{
	449	if (! bfd_cache_init (abfd))
	450	return NULL;
	451	}
	452
	453	return (FILE *) abfd->iostream;
	454	}
	455
	456	/*
	457	INTERNAL_FUNCTION
	458	bfd_cache_lookup_worker
	459
	460	SYNOPSIS
	461	FILE bfd_cache_lookup_worker (bfd abfd);
	462
	463	DESCRIPTION
	464	Called when the macro <<bfd_cache_lookup>> fails to find a
	465	quick answer. Find a file descriptor for @var{abfd}. If
	466	necessary, it open it. If there are already more than
	467	<<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
	468	avoid running out of file descriptors. It will abort rather than
	469	returning NULL if it is unable to (re)open the @var{abfd}.
	470	*/
	471
	472	FILE *
	473	bfd_cache_lookup_worker (bfd *abfd)
	474	{
	475	if ((abfd->flags & BFD_IN_MEMORY) != 0)
	476	abort ();
	477
	478	if (abfd->my_archive)
	479	abfd = abfd->my_archive;
	480
	481	if (abfd->iostream != NULL)
	482	{
	483	/* Move the file to the start of the cache. */
	484	if (abfd != bfd_last_cache)
	485	{
	486	snip (abfd);
	487	insert (abfd);
	488	}
	489	}
	490	else
	491	{
	492	if (bfd_open_file (abfd) == NULL
	493	\|\| abfd->where != (unsigned long) abfd->where
	494	\|\| real_fseek ((FILE *) abfd->iostream, abfd->where, SEEK_SET) != 0)
	495	abort ();
	496	}
	497
	498	return (FILE *) abfd->iostream;
	499	}