1 /* BFD library -- caching of file descriptors.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001
3 Free Software Foundation, Inc.
4 Hacked by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
6 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
26 The file caching mechanism is embedded within BFD and allows
27 the application to open as many BFDs as it wants without
28 regard to the underlying operating system's file descriptor
29 limit (often as low as 20 open files). The module in
30 <<cache.c>> maintains a least recently used list of
31 <<BFD_CACHE_MAX_OPEN>> files, and exports the name
32 <<bfd_cache_lookup>>, which runs around and makes sure that
33 the required BFD is open. If not, then it chooses a file to
34 close, closes it and opens the one wanted, returning its file
43 static void insert
PARAMS ((bfd
*));
44 static void snip
PARAMS ((bfd
*));
45 static boolean close_one
PARAMS ((void));
46 static boolean bfd_cache_delete
PARAMS ((bfd
*));
50 BFD_CACHE_MAX_OPEN macro
53 The maximum number of files which the cache will keep open at
56 .#define BFD_CACHE_MAX_OPEN 10
60 /* The number of BFD files we have open. */
62 static int open_files
;
69 extern bfd *bfd_last_cache;
72 Zero, or a pointer to the topmost BFD on the chain. This is
73 used by the <<bfd_cache_lookup>> macro in @file{libbfd.h} to
74 determine when it can avoid a function call.
84 Check to see if the required BFD is the same as the last one
85 looked up. If so, then it can use the stream in the BFD with
86 impunity, since it can't have changed since the last lookup;
87 otherwise, it has to perform the complicated lookup function.
89 .#define bfd_cache_lookup(x) \
90 . ((x)==bfd_last_cache? \
91 . (FILE*) (bfd_last_cache->iostream): \
92 . bfd_cache_lookup_worker(x))
96 /* Insert a BFD into the cache. */
102 if (bfd_last_cache
== NULL
)
104 abfd
->lru_next
= abfd
;
105 abfd
->lru_prev
= abfd
;
109 abfd
->lru_next
= bfd_last_cache
;
110 abfd
->lru_prev
= bfd_last_cache
->lru_prev
;
111 abfd
->lru_prev
->lru_next
= abfd
;
112 abfd
->lru_next
->lru_prev
= abfd
;
114 bfd_last_cache
= abfd
;
117 /* Remove a BFD from the cache. */
123 abfd
->lru_prev
->lru_next
= abfd
->lru_next
;
124 abfd
->lru_next
->lru_prev
= abfd
->lru_prev
;
125 if (abfd
== bfd_last_cache
)
127 bfd_last_cache
= abfd
->lru_next
;
128 if (abfd
== bfd_last_cache
)
129 bfd_last_cache
= NULL
;
133 /* We need to open a new file, and the cache is full. Find the least
134 recently used cacheable BFD and close it. */
141 if (bfd_last_cache
== NULL
)
145 for (kill
= bfd_last_cache
->lru_prev
;
147 kill
= kill
->lru_prev
)
149 if (kill
== bfd_last_cache
)
159 /* There are no open cacheable BFD's. */
163 kill
->where
= ftell ((FILE *) kill
->iostream
);
165 return bfd_cache_delete (kill
);
168 /* Close a BFD and remove it from the cache. */
171 bfd_cache_delete (abfd
)
176 if (fclose ((FILE *) abfd
->iostream
) == 0)
181 bfd_set_error (bfd_error_system_call
);
186 abfd
->iostream
= NULL
;
197 boolean bfd_cache_init (bfd *abfd);
200 Add a newly opened BFD to the cache.
204 bfd_cache_init (abfd
)
207 BFD_ASSERT (abfd
->iostream
!= NULL
);
208 if (open_files
>= BFD_CACHE_MAX_OPEN
)
223 boolean bfd_cache_close (bfd *abfd);
226 Remove the BFD @var{abfd} from the cache. If the attached file is open,
230 <<false>> is returned if closing the file fails, <<true>> is
231 returned if all is well.
235 bfd_cache_close (abfd
)
238 if (abfd
->iostream
== NULL
239 || (abfd
->flags
& BFD_IN_MEMORY
) != 0)
242 return bfd_cache_delete (abfd
);
250 FILE* bfd_open_file(bfd *abfd);
253 Call the OS to open a file for @var{abfd}. Return the <<FILE *>>
254 (possibly <<NULL>>) that results from this operation. Set up the
255 BFD so that future accesses know the file is open. If the <<FILE *>>
256 returned is <<NULL>>, then it won't have been put in the
257 cache, so it won't have to be removed from it.
264 abfd
->cacheable
= true; /* Allow it to be closed later. */
266 if (open_files
>= BFD_CACHE_MAX_OPEN
)
272 switch (abfd
->direction
)
276 abfd
->iostream
= (PTR
) fopen (abfd
->filename
, FOPEN_RB
);
279 case write_direction
:
280 if (abfd
->opened_once
== true)
282 abfd
->iostream
= (PTR
) fopen (abfd
->filename
, FOPEN_RUB
);
283 if (abfd
->iostream
== NULL
)
284 abfd
->iostream
= (PTR
) fopen (abfd
->filename
, FOPEN_WUB
);
290 Some operating systems won't let us overwrite a running
291 binary. For them, we want to unlink the file first.
293 However, gcc 2.95 will create temporary files using
294 O_EXCL and tight permissions to prevent other users from
295 substituting other .o files during the compilation. gcc
296 will then tell the assembler to use the newly created
297 file as an output file. If we unlink the file here, we
298 open a brief window when another user could still
301 So we unlink the output file if and only if it has
304 /* Don't do this for MSDOS: it doesn't care about overwriting
305 a running binary, but if this file is already open by
306 another BFD, we will be in deep trouble if we delete an
307 open file. In fact, objdump does just that if invoked with
308 the --info option. */
311 if (stat (abfd
->filename
, &s
) == 0 && s
.st_size
!= 0)
312 unlink (abfd
->filename
);
314 abfd
->iostream
= (PTR
) fopen (abfd
->filename
, FOPEN_WUB
);
315 abfd
->opened_once
= true;
320 if (abfd
->iostream
!= NULL
)
322 if (! bfd_cache_init (abfd
))
326 return (FILE *) abfd
->iostream
;
331 bfd_cache_lookup_worker
334 FILE *bfd_cache_lookup_worker(bfd *abfd);
337 Called when the macro <<bfd_cache_lookup>> fails to find a
338 quick answer. Find a file descriptor for @var{abfd}. If
339 necessary, it open it. If there are already more than
340 <<BFD_CACHE_MAX_OPEN>> files open, it tries to close one first, to
341 avoid running out of file descriptors.
345 bfd_cache_lookup_worker (abfd
)
348 if ((abfd
->flags
& BFD_IN_MEMORY
) != 0)
351 if (abfd
->my_archive
)
352 abfd
= abfd
->my_archive
;
354 if (abfd
->iostream
!= NULL
)
356 /* Move the file to the start of the cache. */
357 if (abfd
!= bfd_last_cache
)
365 if (bfd_open_file (abfd
) == NULL
)
367 if (abfd
->where
!= (unsigned long) abfd
->where
)
369 if (fseek ((FILE *) abfd
->iostream
, (long) abfd
->where
, SEEK_SET
) != 0)
373 return (FILE *) abfd
->iostream
;
This page took 0.036172 seconds and 4 git commands to generate.