1 /* opncls.c -- open and close a BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
4 Free Software Foundation, Inc.
6 Written by Cygnus Support.
8 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
30 #define S_IXUSR 0100 /* Execute by owner. */
33 #define S_IXGRP 0010 /* Execute by group. */
36 #define S_IXOTH 0001 /* Execute by others. */
39 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
40 if we do that we can't use fcntl. */
42 /* FIXME: This is no longer used. */
43 long _bfd_chunksize = -1;
45 /* Return a new BFD. All BFD's are allocated through this routine. */
52 nbfd = (bfd *) bfd_zmalloc ((bfd_size_type) sizeof (bfd));
56 nbfd->memory = (PTR) objalloc_create ();
57 if (nbfd->memory == NULL)
59 bfd_set_error (bfd_error_no_memory);
63 nbfd->arch_info = &bfd_default_arch_struct;
65 nbfd->direction = no_direction;
66 nbfd->iostream = NULL;
68 nbfd->sections = (asection *) NULL;
69 nbfd->format = bfd_unknown;
70 nbfd->my_archive = (bfd *) NULL;
72 nbfd->opened_once = false;
73 nbfd->output_has_begun = false;
74 nbfd->section_count = 0;
75 nbfd->usrdata = (PTR) NULL;
76 nbfd->cacheable = false;
77 nbfd->flags = BFD_NO_FLAGS;
78 nbfd->mtime_set = false;
83 /* Allocate a new BFD as a member of archive OBFD. */
86 _bfd_new_bfd_contained_in (obfd)
91 nbfd = _bfd_new_bfd ();
92 nbfd->xvec = obfd->xvec;
93 nbfd->my_archive = obfd;
94 nbfd->direction = read_direction;
95 nbfd->target_defaulted = obfd->target_defaulted;
101 Opening and closing BFDs
110 bfd *bfd_openr(const char *filename, const char *target);
113 Open the file @var{filename} (using <<fopen>>) with the target
114 @var{target}. Return a pointer to the created BFD.
116 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
119 If <<NULL>> is returned then an error has occured. Possible errors
120 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or <<system_call>> error.
124 bfd_openr (filename, target)
125 const char *filename;
129 const bfd_target *target_vec;
131 nbfd = _bfd_new_bfd ();
135 target_vec = bfd_find_target (target, nbfd);
136 if (target_vec == NULL)
138 objalloc_free ((struct objalloc *) nbfd->memory);
140 bfd_set_error (bfd_error_invalid_target);
144 nbfd->filename = filename;
145 nbfd->direction = read_direction;
147 if (bfd_open_file (nbfd) == NULL)
149 /* File didn't exist, or some such */
150 bfd_set_error (bfd_error_system_call);
151 objalloc_free ((struct objalloc *) nbfd->memory);
159 /* Don't try to `optimize' this function:
161 o - We lock using stack space so that interrupting the locking
162 won't cause a storage leak.
163 o - We open the file stream last, since we don't want to have to
164 close it if anything goes wrong. Closing the stream means closing
165 the file descriptor too, even though we didn't open it.
172 bfd *bfd_fdopenr(const char *filename, const char *target, int fd);
175 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to <<fopen>>.
176 It opens a BFD on a file already described by the @var{fd}
179 When the file is later <<bfd_close>>d, the file descriptor will be closed.
181 If the caller desires that this file descriptor be cached by BFD
182 (opened as needed, closed as needed to free descriptors for
183 other opens), with the supplied @var{fd} used as an initial
184 file descriptor (but subject to closure at any time), call
185 bfd_set_cacheable(bfd, 1) on the returned BFD. The default is to
186 assume no cacheing; the file descriptor will remain open until
187 <<bfd_close>>, and will not be affected by BFD operations on other
190 Possible errors are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
194 bfd_fdopenr (filename, target, fd)
195 const char *filename;
200 const bfd_target *target_vec;
203 bfd_set_error (bfd_error_system_call);
204 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
205 fdflags = O_RDWR; /* Assume full access */
207 fdflags = fcntl (fd, F_GETFL, NULL);
209 if (fdflags == -1) return NULL;
211 nbfd = _bfd_new_bfd ();
215 target_vec = bfd_find_target (target, nbfd);
216 if (target_vec == NULL)
218 bfd_set_error (bfd_error_invalid_target);
219 objalloc_free ((struct objalloc *) nbfd->memory);
225 nbfd->iostream = (PTR) fopen (filename, FOPEN_RB);
227 /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
228 switch (fdflags & (O_ACCMODE))
230 case O_RDONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RB); break;
231 case O_WRONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB); break;
232 case O_RDWR: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB); break;
237 if (nbfd->iostream == NULL)
239 objalloc_free ((struct objalloc *) nbfd->memory);
244 /* OK, put everything where it belongs */
246 nbfd->filename = filename;
248 /* As a special case we allow a FD open for read/write to
249 be written through, although doing so requires that we end
250 the previous clause with a preposition. */
251 /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
252 switch (fdflags & (O_ACCMODE))
254 case O_RDONLY: nbfd->direction = read_direction; break;
255 case O_WRONLY: nbfd->direction = write_direction; break;
256 case O_RDWR: nbfd->direction = both_direction; break;
260 if (! bfd_cache_init (nbfd))
262 objalloc_free ((struct objalloc *) nbfd->memory);
266 nbfd->opened_once = true;
276 bfd *bfd_openstreamr(const char *, const char *, PTR);
280 Open a BFD for read access on an existing stdio stream. When
281 the BFD is passed to <<bfd_close>>, the stream will be closed.
285 bfd_openstreamr (filename, target, streamarg)
286 const char *filename;
290 FILE *stream = (FILE *) streamarg;
292 const bfd_target *target_vec;
294 nbfd = _bfd_new_bfd ();
298 target_vec = bfd_find_target (target, nbfd);
299 if (target_vec == NULL)
301 bfd_set_error (bfd_error_invalid_target);
302 objalloc_free ((struct objalloc *) nbfd->memory);
307 nbfd->iostream = (PTR) stream;
308 nbfd->filename = filename;
309 nbfd->direction = read_direction;
311 if (! bfd_cache_init (nbfd))
313 objalloc_free ((struct objalloc *) nbfd->memory);
321 /** bfd_openw -- open for writing.
322 Returns a pointer to a freshly-allocated BFD on success, or NULL.
324 See comment by bfd_fdopenr before you try to modify this function. */
331 bfd *bfd_openw(const char *filename, const char *target);
334 Create a BFD, associated with file @var{filename}, using the
335 file format @var{target}, and return a pointer to it.
337 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
338 <<bfd_error_invalid_target>>.
342 bfd_openw (filename, target)
343 const char *filename;
347 const bfd_target *target_vec;
349 bfd_set_error (bfd_error_system_call);
351 /* nbfd has to point to head of malloc'ed block so that bfd_close may
352 reclaim it correctly. */
354 nbfd = _bfd_new_bfd ();
358 target_vec = bfd_find_target (target, nbfd);
359 if (target_vec == NULL)
361 objalloc_free ((struct objalloc *) nbfd->memory);
366 nbfd->filename = filename;
367 nbfd->direction = write_direction;
369 if (bfd_open_file (nbfd) == NULL)
371 bfd_set_error (bfd_error_system_call); /* File not writeable, etc */
372 objalloc_free ((struct objalloc *) nbfd->memory);
386 boolean bfd_close(bfd *abfd);
390 Close a BFD. If the BFD was open for writing,
391 then pending operations are completed and the file written out
392 and closed. If the created file is executable, then
393 <<chmod>> is called to mark it as such.
395 All memory attached to the BFD is released.
397 The file descriptor associated with the BFD is closed (even
398 if it was passed in to BFD by <<bfd_fdopenr>>).
401 <<true>> is returned if all is ok, otherwise <<false>>.
411 if (!bfd_read_p (abfd))
413 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
417 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
420 ret = bfd_cache_close (abfd);
422 /* If the file was open for writing and is now executable,
425 && abfd->direction == write_direction
426 && abfd->flags & EXEC_P)
430 if (stat (abfd->filename, &buf) == 0)
432 unsigned int mask = umask (0);
434 chmod (abfd->filename,
436 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
440 objalloc_free ((struct objalloc *) abfd->memory);
451 boolean bfd_close_all_done(bfd *);
454 Close a BFD. Differs from <<bfd_close>>
455 since it does not complete any pending operations. This
456 routine would be used if the application had just used BFD for
457 swapping and didn't want to use any of the writing code.
459 If the created file is executable, then <<chmod>> is called
462 All memory attached to the BFD is released.
465 <<true>> is returned if all is ok, otherwise <<false>>.
470 bfd_close_all_done (abfd)
475 ret = bfd_cache_close (abfd);
477 /* If the file was open for writing and is now executable,
480 && abfd->direction == write_direction
481 && abfd->flags & EXEC_P)
485 if (stat (abfd->filename, &buf) == 0)
487 unsigned int mask = umask (0);
489 chmod (abfd->filename,
491 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
495 objalloc_free ((struct objalloc *) abfd->memory);
506 bfd *bfd_create(const char *filename, bfd *templ);
509 Create a new BFD in the manner of
510 <<bfd_openw>>, but without opening a file. The new BFD
511 takes the target from the target used by @var{template}. The
512 format is always set to <<bfd_object>>.
517 bfd_create (filename, templ)
518 const char *filename;
523 nbfd = _bfd_new_bfd ();
526 nbfd->filename = filename;
528 nbfd->xvec = templ->xvec;
529 nbfd->direction = no_direction;
530 bfd_set_format (nbfd, bfd_object);
539 boolean bfd_make_writable(bfd *abfd);
542 Takes a BFD as created by <<bfd_create>> and converts it
543 into one like as returned by <<bfd_openw>>. It does this
544 by converting the BFD to BFD_IN_MEMORY. It's assumed that
545 you will call <<bfd_make_readable>> on this bfd later.
548 <<true>> is returned if all is ok, otherwise <<false>>.
552 bfd_make_writable(abfd)
555 struct bfd_in_memory *bim;
557 if (abfd->direction != no_direction)
559 bfd_set_error (bfd_error_invalid_operation);
563 bim = ((struct bfd_in_memory *)
564 bfd_malloc ((bfd_size_type) sizeof (struct bfd_in_memory)));
565 abfd->iostream = (PTR) bim;
566 /* bfd_bwrite will grow these as needed */
570 abfd->flags |= BFD_IN_MEMORY;
571 abfd->direction = write_direction;
582 boolean bfd_make_readable(bfd *abfd);
585 Takes a BFD as created by <<bfd_create>> and
586 <<bfd_make_writable>> and converts it into one like as
587 returned by <<bfd_openr>>. It does this by writing the
588 contents out to the memory buffer, then reversing the
592 <<true>> is returned if all is ok, otherwise <<false>>. */
595 bfd_make_readable(abfd)
598 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
600 bfd_set_error (bfd_error_invalid_operation);
604 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
607 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
611 abfd->arch_info = &bfd_default_arch_struct;
614 abfd->sections = (asection *) NULL;
615 abfd->format = bfd_unknown;
616 abfd->my_archive = (bfd *) NULL;
618 abfd->opened_once = false;
619 abfd->output_has_begun = false;
620 abfd->section_count = 0;
621 abfd->usrdata = (PTR) NULL;
622 abfd->cacheable = false;
623 abfd->flags = BFD_IN_MEMORY;
624 abfd->mtime_set = false;
626 abfd->target_defaulted = true;
627 abfd->direction = read_direction;
630 abfd->outsymbols = 0;
633 bfd_check_format(abfd, bfd_object);
643 PTR bfd_alloc (bfd *abfd, size_t wanted);
646 Allocate a block of @var{wanted} bytes of memory attached to
647 <<abfd>> and return a pointer to it.
652 bfd_alloc (abfd, size)
658 if (size != (unsigned long) size)
660 bfd_set_error (bfd_error_no_memory);
664 ret = objalloc_alloc (abfd->memory, (unsigned long) size);
666 bfd_set_error (bfd_error_no_memory);
671 bfd_zalloc (abfd, size)
677 res = bfd_alloc (abfd, size);
679 memset (res, 0, (size_t) size);
683 /* Free a block allocated for a BFD. */
686 bfd_release (abfd, block)
690 objalloc_free_block ((struct objalloc *) abfd->memory, block);