* aoutx.h (NAME(aout,find_nearest_line)): Handle the case
[platform/upstream/binutils.git] / bfd / opncls.c
1 /* opncls.c -- open and close a BFD.
2    Copyright (C) 1990-1991 Free Software Foundation, Inc.
3    Written by Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
20
21 /* $Id$ */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libbfd.h"
26 #include "obstack.h"
27 extern void bfd_cache_init();
28 FILE *bfd_open_file();
29
30 /* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
31    if we do that we can't use fcntl.  */
32
33
34 #define obstack_chunk_alloc bfd_xmalloc
35 #define obstack_chunk_free free
36
37 /* Return a new BFD.  All BFD's are allocated through this routine.  */
38
39 bfd *new_bfd()
40 {
41   bfd *nbfd;
42
43   nbfd = (bfd *)zalloc (sizeof (bfd));
44   if (!nbfd)
45     return 0;
46
47   bfd_check_init();
48   obstack_begin((PTR)&nbfd->memory, 128);
49
50   nbfd->arch_info = &bfd_default_arch_struct;
51
52   nbfd->direction = no_direction;
53   nbfd->iostream = NULL;
54   nbfd->where = 0;
55   nbfd->sections = (asection *)NULL;
56   nbfd->format = bfd_unknown;
57   nbfd->my_archive = (bfd *)NULL;
58   nbfd->origin = 0;                                
59   nbfd->opened_once = false;
60   nbfd->output_has_begun = false;
61   nbfd->section_count = 0;
62   nbfd->usrdata = (PTR)NULL;
63   nbfd->sections = (asection *)NULL;
64   nbfd->cacheable = false;
65   nbfd->flags = NO_FLAGS;
66   nbfd->mtime_set = 0;
67   return nbfd;
68 }
69
70 /* Allocate a new BFD as a member of archive OBFD.  */
71
72 bfd *new_bfd_contained_in(obfd)
73 bfd *obfd;
74 {
75         bfd *nbfd = new_bfd();
76         nbfd->xvec = obfd->xvec;
77         nbfd->my_archive = obfd;
78         nbfd->direction = read_direction;
79         return nbfd;
80 }
81
82 /*doc*
83 @section Opening and Closing BFDs
84
85 */
86 /*proto*
87 *i bfd_openr
88 Opens the file supplied (using @code{fopen}) with the target supplied, it
89 returns a pointer to the created BFD.
90
91 If NULL is returned then an error has occured.
92 Possible errors are no_memory, invalid_target or system_call error.
93 *; PROTO(bfd*, bfd_openr, (CONST char *filename,CONST char*target));
94 *-*/
95
96 bfd *
97 DEFUN(bfd_openr, (filename, target),
98       CONST char *filename AND
99       CONST char *target)
100 {
101   bfd *nbfd;
102   bfd_target *target_vec;
103
104   nbfd = new_bfd();
105   if (nbfd == NULL) {
106     bfd_error = no_memory;
107     return NULL;
108   }
109
110   target_vec = bfd_find_target (target, nbfd);
111   if (target_vec == NULL) {
112     bfd_error = invalid_target;
113     return NULL;
114   }
115
116   nbfd->filename = filename;
117   nbfd->direction = read_direction; 
118
119   if (bfd_open_file (nbfd) == NULL) {
120     bfd_error = system_call_error;      /* File didn't exist, or some such */
121     bfd_release(nbfd,0);
122     return NULL;
123   }
124   return nbfd;
125 }
126
127
128 /* Don't try to `optimize' this function:
129
130    o - We lock using stack space so that interrupting the locking
131        won't cause a storage leak.
132    o - We open the file stream last, since we don't want to have to
133        close it if anything goes wrong.  Closing the stream means closing
134        the file descriptor too, even though we didn't open it.
135  */
136 /*proto*
137 *i bfd_fdopenr
138 bfd_fdopenr is to bfd_fopenr much like  fdopen is to fopen. It opens a BFD on
139 a file already described by the @var{fd} supplied. 
140
141 Possible errors are no_memory, invalid_target and system_call error.
142 *;  PROTO(bfd *, bfd_fdopenr,
143     (CONST char *filename, CONST char *target, int fd));
144 *-*/
145
146 bfd *
147 DEFUN(bfd_fdopenr,(filename, target, fd),
148       CONST char *filename AND
149       CONST char *target AND
150       int fd)
151 {
152   bfd *nbfd;
153   bfd_target *target_vec;
154   int fdflags;
155
156   bfd_error = system_call_error;
157   
158 #ifdef NO_FCNTL
159   fdflags = O_RDWR;                     /* Assume full access */
160 #else
161   fdflags = fcntl (fd, F_GETFL, NULL);
162 #endif
163   if (fdflags == -1) return NULL;
164
165   nbfd = new_bfd();
166
167   if (nbfd == NULL) {
168     bfd_error = no_memory;
169     return NULL;
170   }
171
172   target_vec = bfd_find_target (target, nbfd);
173   if (target_vec == NULL) {
174     bfd_error = invalid_target;
175     return NULL;
176   }
177
178 #ifdef FASCIST_FDOPEN
179   nbfd->iostream = (char *) fdopen (fd, "r"); 
180 #else
181   /* if the fd were open for read only, this still would not hurt: */
182   nbfd->iostream = (char *) fdopen (fd, "r+"); 
183 #endif
184   if (nbfd->iostream == NULL) {
185     (void) obstack_free (&nbfd->memory, (PTR)0);
186     return NULL;
187   }
188   
189   /* OK, put everything where it belongs */
190
191   nbfd->filename = filename;
192
193   /* As a special case we allow a FD open for read/write to
194      be written through, although doing so requires that we end
195      the previous clause with a preposition.  */
196   /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
197   switch (fdflags & (O_ACCMODE)) {
198   case O_RDONLY: nbfd->direction = read_direction; break;
199   case O_WRONLY: nbfd->direction = write_direction; break;  
200   case O_RDWR: nbfd->direction = both_direction; break;
201   default: abort ();
202   }
203                                    
204   bfd_cache_init (nbfd);
205
206   return nbfd;
207 }
208 \f
209 /** bfd_openw -- open for writing.
210   Returns a pointer to a freshly-allocated BFD on success, or NULL.
211
212   See comment by bfd_fdopenr before you try to modify this function. */
213
214 /*proto* bfd_openw
215 Creates a BFD, associated with file @var{filename}, using the file
216 format @var{target}, and returns a pointer to it.
217
218 Possible errors are system_call_error, no_memory, invalid_target.
219 *; PROTO(bfd *, bfd_openw, (CONST char *filename, CONST char *target));
220 */
221
222 bfd *
223 DEFUN(bfd_openw,(filename, target),
224       CONST char *filename AND
225       CONST char *target)
226 {
227   bfd *nbfd;
228   bfd_target *target_vec;
229   
230   bfd_error = system_call_error;
231
232   /* nbfd has to point to head of malloc'ed block so that bfd_close may
233      reclaim it correctly. */
234
235   nbfd = new_bfd();
236   if (nbfd == NULL) {
237     bfd_error = no_memory;
238     return NULL;
239   }
240
241   target_vec = bfd_find_target (target, nbfd);
242   if (target_vec == NULL) return NULL;
243
244   nbfd->filename = filename;
245   nbfd->direction = write_direction;
246
247   if (bfd_open_file (nbfd) == NULL) {
248     bfd_error = system_call_error;      /* File not writeable, etc */
249     (void) obstack_free (&nbfd->memory, (PTR)0);
250     return NULL;
251   }
252   return nbfd;
253 }
254
255 /*proto* bfd_close
256 This function closes a BFD. If the BFD was open for writing, then
257 pending operations are completed and the file written out and closed.
258 If the created file is executable, then @code{chmod} is called to mark
259 it as such.
260
261 All memory attached to the BFD's obstacks is released. 
262
263 @code{true} is returned if all is ok, otherwise @code{false}.
264 *; PROTO(boolean, bfd_close,(bfd *));
265 */
266
267 boolean
268 DEFUN(bfd_close,(abfd),
269       bfd *abfd)
270 {
271   if (!bfd_read_p(abfd))
272     if (BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)) != true)
273       return false;
274
275   if (BFD_SEND (abfd, _close_and_cleanup, (abfd)) != true) return false;
276
277   bfd_cache_close(abfd);
278
279   /* If the file was open for writing and is now executable,
280      make it so */
281   if (abfd->direction == write_direction 
282       && abfd->flags & EXEC_P) {
283     struct stat buf;
284     stat(abfd->filename, &buf);
285 #ifndef S_IXUSR
286 #define S_IXUSR 0100    /* Execute by owner.  */
287 #endif
288 #ifndef S_IXGRP
289 #define S_IXGRP 0010    /* Execute by group.  */
290 #endif
291 #ifndef S_IXOTH
292 #define S_IXOTH 0001    /* Execute by others.  */
293 #endif
294
295     chmod(abfd->filename,buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH);
296   }
297   (void) obstack_free (&abfd->memory, (PTR)0);
298   (void) free(abfd);
299   return true;
300 }
301
302 /*proto* bfd_close_all_done
303 This function closes a BFD. It differs from @code{bfd_close} since it
304 does not complete any pending operations.  This routine would be used
305 if the application had just used BFD for swapping and didn't want to
306 use any of the writing code.
307
308 If the created file is executable, then @code{chmod} is called to mark
309 it as such.
310
311 All memory attached to the BFD's obstacks is released. 
312
313 @code{true} is returned if all is ok, otherwise @code{false}.
314 *; PROTO(boolean, bfd_close_all_done,(bfd *));
315 */
316
317 boolean
318 DEFUN(bfd_close_all_done,(abfd),
319       bfd *abfd)
320 {
321   bfd_cache_close(abfd);
322
323   /* If the file was open for writing and is now executable,
324      make it so */
325   if (abfd->direction == write_direction 
326       && abfd->flags & EXEC_P) {
327     struct stat buf;
328     stat(abfd->filename, &buf);
329 #ifndef S_IXUSR
330 #define S_IXUSR 0100    /* Execute by owner.  */
331 #endif
332 #ifndef S_IXGRP
333 #define S_IXGRP 0010    /* Execute by group.  */
334 #endif
335 #ifndef S_IXOTH
336 #define S_IXOTH 0001    /* Execute by others.  */
337 #endif
338
339     chmod(abfd->filename,buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH);
340   }
341   (void) obstack_free (&abfd->memory, (PTR)0);
342   (void) free(abfd);
343   return true;
344 }
345
346 /*proto* bfd_create
347 This routine creates a new BFD in the manner of @code{bfd_openw}, but without
348 opening a file. The new BFD takes the target from the target used by
349 @var{template}. The format is always set to @code{bfd_object}.
350
351 *; PROTO(bfd *, bfd_create, (CONST char *filename, bfd *template));
352 */
353
354 bfd *
355 DEFUN(bfd_create,(filename, template),
356       CONST char *filename AND
357       bfd *template)
358 {
359   bfd *nbfd = new_bfd();
360   if (nbfd == (bfd *)NULL) {
361     bfd_error = no_memory;
362     return (bfd *)NULL;
363   }
364   nbfd->filename = filename;
365   if(template) {
366     nbfd->xvec = template->xvec;
367   }
368   nbfd->direction = no_direction;
369   bfd_set_format(nbfd, bfd_object);
370   return nbfd;
371 }
372
373 /* Memory allocation */
374
375 DEFUN(PTR bfd_alloc_by_size_t,(abfd, size),
376       bfd *abfd AND
377       size_t size)
378 {
379   PTR res = obstack_alloc(&(abfd->memory), size);
380   return res;
381 }
382
383 DEFUN(void bfd_alloc_grow,(abfd, ptr, size),
384       bfd *abfd AND
385       PTR ptr AND
386       bfd_size_type size)
387 {
388   (void)   obstack_grow(&(abfd->memory), ptr, size);
389 }
390 DEFUN(PTR bfd_alloc_finish,(abfd),
391       bfd *abfd)
392 {
393   return obstack_finish(&(abfd->memory));
394 }
395
396 DEFUN(PTR bfd_alloc, (abfd, size),
397       bfd *abfd AND
398       bfd_size_type size)
399 {
400   return bfd_alloc_by_size_t(abfd, (size_t)size);
401 }
402
403 DEFUN(PTR bfd_zalloc,(abfd, size),
404       bfd *abfd AND
405       bfd_size_type size)
406 {
407   PTR res = bfd_alloc(abfd, size);
408   memset(res, 0, (size_t)size);
409   return res;
410 }
411
412 DEFUN(PTR bfd_realloc,(abfd, old, size),
413       bfd *abfd AND
414       PTR old AND
415       bfd_size_type size)
416 {
417   PTR res = bfd_alloc(abfd, size);
418   memcpy(res, old, (size_t)size);
419   return res;
420 }
421
422 /*proto* bfd_alloc_size
423 Return the number of bytes in the obstacks connected to the supplied
424 BFD.
425 *; PROTO(bfd_size_type,bfd_alloc_size,(bfd *abfd));
426 */
427
428 bfd_size_type
429 DEFUN( bfd_alloc_size,(abfd),
430       bfd *abfd)
431 {
432   struct _obstack_chunk *chunk = abfd->memory.chunk;
433   size_t size = 0;
434   while (chunk) {
435     size += chunk->limit - &(chunk->contents[0]);
436     chunk = chunk->prev;
437   }
438   return size;
439 }