* aout-adobe.c: Don't compare against "true" or "false.
[external/binutils.git] / bfd / cache.c
1 /* BFD library -- caching of file descriptors.
2    Copyright 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002
3    Free Software Foundation, Inc.
4    Hacked by Steve Chamberlain of Cygnus Support (steve@cygnus.com).
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 /*
23 SECTION
24         File caching
25
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
35         handle.
36
37 */
38
39 #include "bfd.h"
40 #include "sysdep.h"
41 #include "libbfd.h"
42
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 *));
47
48 /*
49 INTERNAL_FUNCTION
50         BFD_CACHE_MAX_OPEN macro
51
52 DESCRIPTION
53         The maximum number of files which the cache will keep open at
54         one time.
55
56 .#define BFD_CACHE_MAX_OPEN 10
57
58 */
59
60 /* The number of BFD files we have open.  */
61
62 static int open_files;
63
64 /*
65 INTERNAL_FUNCTION
66         bfd_last_cache
67
68 SYNOPSIS
69         extern bfd *bfd_last_cache;
70
71 DESCRIPTION
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.
75 */
76
77 bfd *bfd_last_cache;
78
79 /*
80   INTERNAL_FUNCTION
81         bfd_cache_lookup
82
83   DESCRIPTION
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.
88
89   .#define bfd_cache_lookup(x) \
90   .    ((x)==bfd_last_cache? \
91   .      (FILE*) (bfd_last_cache->iostream): \
92   .       bfd_cache_lookup_worker(x))
93
94  */
95
96 /* Insert a BFD into the cache.  */
97
98 static INLINE void
99 insert (abfd)
100      bfd *abfd;
101 {
102   if (bfd_last_cache == NULL)
103     {
104       abfd->lru_next = abfd;
105       abfd->lru_prev = abfd;
106     }
107   else
108     {
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;
113     }
114   bfd_last_cache = abfd;
115 }
116
117 /* Remove a BFD from the cache.  */
118
119 static INLINE void
120 snip (abfd)
121      bfd *abfd;
122 {
123   abfd->lru_prev->lru_next = abfd->lru_next;
124   abfd->lru_next->lru_prev = abfd->lru_prev;
125   if (abfd == bfd_last_cache)
126     {
127       bfd_last_cache = abfd->lru_next;
128       if (abfd == bfd_last_cache)
129         bfd_last_cache = NULL;
130     }
131 }
132
133 /* We need to open a new file, and the cache is full.  Find the least
134    recently used cacheable BFD and close it.  */
135
136 static boolean
137 close_one ()
138 {
139   register bfd *kill;
140
141   if (bfd_last_cache == NULL)
142     kill = NULL;
143   else
144     {
145       for (kill = bfd_last_cache->lru_prev;
146            ! kill->cacheable;
147            kill = kill->lru_prev)
148         {
149           if (kill == bfd_last_cache)
150             {
151               kill = NULL;
152               break;
153             }
154         }
155     }
156
157   if (kill == NULL)
158     {
159       /* There are no open cacheable BFD's.  */
160       return true;
161     }
162
163   kill->where = ftell ((FILE *) kill->iostream);
164
165   return bfd_cache_delete (kill);
166 }
167
168 /* Close a BFD and remove it from the cache.  */
169
170 static boolean
171 bfd_cache_delete (abfd)
172      bfd *abfd;
173 {
174   boolean ret;
175
176   if (fclose ((FILE *) abfd->iostream) == 0)
177     ret = true;
178   else
179     {
180       ret = false;
181       bfd_set_error (bfd_error_system_call);
182     }
183
184   snip (abfd);
185
186   abfd->iostream = NULL;
187   --open_files;
188
189   return ret;
190 }
191
192 /*
193 INTERNAL_FUNCTION
194         bfd_cache_init
195
196 SYNOPSIS
197         boolean bfd_cache_init (bfd *abfd);
198
199 DESCRIPTION
200         Add a newly opened BFD to the cache.
201 */
202
203 boolean
204 bfd_cache_init (abfd)
205      bfd *abfd;
206 {
207   BFD_ASSERT (abfd->iostream != NULL);
208   if (open_files >= BFD_CACHE_MAX_OPEN)
209     {
210       if (! close_one ())
211         return false;
212     }
213   insert (abfd);
214   ++open_files;
215   return true;
216 }
217
218 /*
219 INTERNAL_FUNCTION
220         bfd_cache_close
221
222 SYNOPSIS
223         boolean bfd_cache_close (bfd *abfd);
224
225 DESCRIPTION
226         Remove the BFD @var{abfd} from the cache. If the attached file is open,
227         then close it too.
228
229 RETURNS
230         <<false>> is returned if closing the file fails, <<true>> is
231         returned if all is well.
232 */
233
234 boolean
235 bfd_cache_close (abfd)
236      bfd *abfd;
237 {
238   if (abfd->iostream == NULL
239       || (abfd->flags & BFD_IN_MEMORY) != 0)
240     return true;
241
242   return bfd_cache_delete (abfd);
243 }
244
245 /*
246 INTERNAL_FUNCTION
247         bfd_open_file
248
249 SYNOPSIS
250         FILE* bfd_open_file(bfd *abfd);
251
252 DESCRIPTION
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.
258 */
259
260 FILE *
261 bfd_open_file (abfd)
262      bfd *abfd;
263 {
264   abfd->cacheable = true;       /* Allow it to be closed later.  */
265
266   if (open_files >= BFD_CACHE_MAX_OPEN)
267     {
268       if (! close_one ())
269         return NULL;
270     }
271
272   switch (abfd->direction)
273     {
274     case read_direction:
275     case no_direction:
276       abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RB);
277       break;
278     case both_direction:
279     case write_direction:
280       if (abfd->opened_once)
281         {
282           abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_RUB);
283           if (abfd->iostream == NULL)
284             abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
285         }
286       else
287         {
288           /* Create the file.
289
290              Some operating systems won't let us overwrite a running
291              binary.  For them, we want to unlink the file first.
292
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
299              substitute a file.
300
301              So we unlink the output file if and only if it has
302              non-zero size.  */
303 #ifndef __MSDOS__
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.  */
309           struct stat s;
310
311           if (stat (abfd->filename, &s) == 0 && s.st_size != 0)
312             unlink (abfd->filename);
313 #endif
314           abfd->iostream = (PTR) fopen (abfd->filename, FOPEN_WUB);
315           abfd->opened_once = true;
316         }
317       break;
318     }
319
320   if (abfd->iostream != NULL)
321     {
322       if (! bfd_cache_init (abfd))
323         return NULL;
324     }
325
326   return (FILE *) abfd->iostream;
327 }
328
329 /*
330 INTERNAL_FUNCTION
331         bfd_cache_lookup_worker
332
333 SYNOPSIS
334         FILE *bfd_cache_lookup_worker(bfd *abfd);
335
336 DESCRIPTION
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.
342 */
343
344 FILE *
345 bfd_cache_lookup_worker (abfd)
346      bfd *abfd;
347 {
348   if ((abfd->flags & BFD_IN_MEMORY) != 0)
349     abort ();
350
351   if (abfd->my_archive)
352     abfd = abfd->my_archive;
353
354   if (abfd->iostream != NULL)
355     {
356       /* Move the file to the start of the cache.  */
357       if (abfd != bfd_last_cache)
358         {
359           snip (abfd);
360           insert (abfd);
361         }
362     }
363   else
364     {
365       if (bfd_open_file (abfd) == NULL)
366         return NULL;
367       if (abfd->where != (unsigned long) abfd->where)
368         return NULL;
369       if (fseek ((FILE *) abfd->iostream, (long) abfd->where, SEEK_SET) != 0)
370         return NULL;
371     }
372
373   return (FILE *) abfd->iostream;
374 }