2010-05-25 Tristan Gingold <gingold@adacore.com>
[binutils.git] / bfd / opncls.c
blob79c3274bcc107deb5812c80b43750978aa3664a6
1 /* opncls.c -- open and close a BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 3 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., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "objalloc.h"
28 #include "libbfd.h"
29 #include "libiberty.h"
31 #ifndef S_IXUSR
32 #define S_IXUSR 0100 /* Execute by owner. */
33 #endif
34 #ifndef S_IXGRP
35 #define S_IXGRP 0010 /* Execute by group. */
36 #endif
37 #ifndef S_IXOTH
38 #define S_IXOTH 0001 /* Execute by others. */
39 #endif
41 /* Counter used to initialize the bfd identifier. */
43 static unsigned int _bfd_id_counter = 0;
45 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
46 if we do that we can't use fcntl. */
48 /* Return a new BFD. All BFD's are allocated through this routine. */
50 bfd *
51 _bfd_new_bfd (void)
53 bfd *nbfd;
55 nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
56 if (nbfd == NULL)
57 return NULL;
59 nbfd->id = _bfd_id_counter++;
61 nbfd->memory = objalloc_create ();
62 if (nbfd->memory == NULL)
64 bfd_set_error (bfd_error_no_memory);
65 free (nbfd);
66 return NULL;
69 nbfd->arch_info = &bfd_default_arch_struct;
71 nbfd->direction = no_direction;
72 nbfd->iostream = NULL;
73 nbfd->where = 0;
74 if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
75 sizeof (struct section_hash_entry), 251))
77 free (nbfd);
78 return NULL;
80 nbfd->sections = NULL;
81 nbfd->section_last = NULL;
82 nbfd->format = bfd_unknown;
83 nbfd->my_archive = NULL;
84 nbfd->origin = 0;
85 nbfd->opened_once = FALSE;
86 nbfd->output_has_begun = FALSE;
87 nbfd->section_count = 0;
88 nbfd->usrdata = NULL;
89 nbfd->cacheable = FALSE;
90 nbfd->flags = BFD_NO_FLAGS;
91 nbfd->mtime_set = FALSE;
93 return nbfd;
96 /* Allocate a new BFD as a member of archive OBFD. */
98 bfd *
99 _bfd_new_bfd_contained_in (bfd *obfd)
101 bfd *nbfd;
103 nbfd = _bfd_new_bfd ();
104 if (nbfd == NULL)
105 return NULL;
106 nbfd->xvec = obfd->xvec;
107 nbfd->iovec = obfd->iovec;
108 nbfd->my_archive = obfd;
109 nbfd->direction = read_direction;
110 nbfd->target_defaulted = obfd->target_defaulted;
111 return nbfd;
114 /* Delete a BFD. */
116 void
117 _bfd_delete_bfd (bfd *abfd)
119 if (abfd->memory)
121 bfd_hash_table_free (&abfd->section_htab);
122 objalloc_free ((struct objalloc *) abfd->memory);
124 free (abfd);
127 /* Free objalloc memory. */
129 bfd_boolean
130 _bfd_free_cached_info (bfd *abfd)
132 if (abfd->memory)
134 bfd_hash_table_free (&abfd->section_htab);
135 objalloc_free ((struct objalloc *) abfd->memory);
137 abfd->sections = NULL;
138 abfd->section_last = NULL;
139 abfd->outsymbols = NULL;
140 abfd->tdata.any = NULL;
141 abfd->usrdata = NULL;
142 abfd->memory = NULL;
145 return TRUE;
149 SECTION
150 Opening and closing BFDs
152 SUBSECTION
153 Functions for opening and closing
157 FUNCTION
158 bfd_fopen
160 SYNOPSIS
161 bfd *bfd_fopen (const char *filename, const char *target,
162 const char *mode, int fd);
164 DESCRIPTION
165 Open the file @var{filename} with the target @var{target}.
166 Return a pointer to the created BFD. If @var{fd} is not -1,
167 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
168 is used. @var{mode} is passed directly to <<fopen>> or
169 <<fdopen>>.
171 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
172 that function.
174 The new BFD is marked as cacheable iff @var{fd} is -1.
176 If <<NULL>> is returned then an error has occured. Possible errors
177 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
178 <<system_call>> error.
181 bfd *
182 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
184 bfd *nbfd;
185 const bfd_target *target_vec;
187 nbfd = _bfd_new_bfd ();
188 if (nbfd == NULL)
189 return NULL;
191 target_vec = bfd_find_target (target, nbfd);
192 if (target_vec == NULL)
194 _bfd_delete_bfd (nbfd);
195 return NULL;
198 #ifdef HAVE_FDOPEN
199 if (fd != -1)
200 nbfd->iostream = fdopen (fd, mode);
201 else
202 #endif
203 nbfd->iostream = real_fopen (filename, mode);
204 if (nbfd->iostream == NULL)
206 bfd_set_error (bfd_error_system_call);
207 _bfd_delete_bfd (nbfd);
208 return NULL;
211 /* OK, put everything where it belongs. */
212 nbfd->filename = filename;
214 /* Figure out whether the user is opening the file for reading,
215 writing, or both, by looking at the MODE argument. */
216 if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
217 && mode[1] == '+')
218 nbfd->direction = both_direction;
219 else if (mode[0] == 'r')
220 nbfd->direction = read_direction;
221 else
222 nbfd->direction = write_direction;
224 if (! bfd_cache_init (nbfd))
226 _bfd_delete_bfd (nbfd);
227 return NULL;
229 nbfd->opened_once = TRUE;
230 /* If we opened the file by name, mark it cacheable; we can close it
231 and reopen it later. However, if a file descriptor was provided,
232 then it may have been opened with special flags that make it
233 unsafe to close and reopen the file. */
234 if (fd == -1)
235 bfd_set_cacheable (nbfd, TRUE);
237 return nbfd;
241 FUNCTION
242 bfd_openr
244 SYNOPSIS
245 bfd *bfd_openr (const char *filename, const char *target);
247 DESCRIPTION
248 Open the file @var{filename} (using <<fopen>>) with the target
249 @var{target}. Return a pointer to the created BFD.
251 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
252 that function.
254 If <<NULL>> is returned then an error has occured. Possible errors
255 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
256 <<system_call>> error.
259 bfd *
260 bfd_openr (const char *filename, const char *target)
262 return bfd_fopen (filename, target, FOPEN_RB, -1);
265 /* Don't try to `optimize' this function:
267 o - We lock using stack space so that interrupting the locking
268 won't cause a storage leak.
269 o - We open the file stream last, since we don't want to have to
270 close it if anything goes wrong. Closing the stream means closing
271 the file descriptor too, even though we didn't open it. */
273 FUNCTION
274 bfd_fdopenr
276 SYNOPSIS
277 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
279 DESCRIPTION
280 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
281 <<fopen>>. It opens a BFD on a file already described by the
282 @var{fd} supplied.
284 When the file is later <<bfd_close>>d, the file descriptor will
285 be closed. If the caller desires that this file descriptor be
286 cached by BFD (opened as needed, closed as needed to free
287 descriptors for other opens), with the supplied @var{fd} used as
288 an initial file descriptor (but subject to closure at any time),
289 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
290 is to assume no caching; the file descriptor will remain open
291 until <<bfd_close>>, and will not be affected by BFD operations
292 on other files.
294 Possible errors are <<bfd_error_no_memory>>,
295 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
298 bfd *
299 bfd_fdopenr (const char *filename, const char *target, int fd)
301 const char *mode;
302 #if defined(HAVE_FCNTL) && defined(F_GETFL)
303 int fdflags;
304 #endif
306 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
307 mode = FOPEN_RUB; /* Assume full access. */
308 #else
309 fdflags = fcntl (fd, F_GETFL, NULL);
310 if (fdflags == -1)
312 bfd_set_error (bfd_error_system_call);
313 return NULL;
316 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
317 switch (fdflags & (O_ACCMODE))
319 case O_RDONLY: mode = FOPEN_RB; break;
320 case O_WRONLY: mode = FOPEN_RUB; break;
321 case O_RDWR: mode = FOPEN_RUB; break;
322 default: abort ();
324 #endif
326 return bfd_fopen (filename, target, mode, fd);
330 FUNCTION
331 bfd_openstreamr
333 SYNOPSIS
334 bfd *bfd_openstreamr (const char *, const char *, void *);
336 DESCRIPTION
338 Open a BFD for read access on an existing stdio stream. When
339 the BFD is passed to <<bfd_close>>, the stream will be closed.
342 bfd *
343 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
345 FILE *stream = (FILE *) streamarg;
346 bfd *nbfd;
347 const bfd_target *target_vec;
349 nbfd = _bfd_new_bfd ();
350 if (nbfd == NULL)
351 return NULL;
353 target_vec = bfd_find_target (target, nbfd);
354 if (target_vec == NULL)
356 _bfd_delete_bfd (nbfd);
357 return NULL;
360 nbfd->iostream = stream;
361 nbfd->filename = filename;
362 nbfd->direction = read_direction;
364 if (! bfd_cache_init (nbfd))
366 _bfd_delete_bfd (nbfd);
367 return NULL;
370 return nbfd;
374 FUNCTION
375 bfd_openr_iovec
377 SYNOPSIS
378 bfd *bfd_openr_iovec (const char *filename, const char *target,
379 void *(*open_func) (struct bfd *nbfd,
380 void *open_closure),
381 void *open_closure,
382 file_ptr (*pread_func) (struct bfd *nbfd,
383 void *stream,
384 void *buf,
385 file_ptr nbytes,
386 file_ptr offset),
387 int (*close_func) (struct bfd *nbfd,
388 void *stream),
389 int (*stat_func) (struct bfd *abfd,
390 void *stream,
391 struct stat *sb));
393 DESCRIPTION
395 Create and return a BFD backed by a read-only @var{stream}.
396 The @var{stream} is created using @var{open_func}, accessed using
397 @var{pread_func} and destroyed using @var{close_func}.
399 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
400 that function.
402 Calls @var{open_func} (which can call <<bfd_zalloc>> and
403 <<bfd_get_filename>>) to obtain the read-only stream backing
404 the BFD. @var{open_func} either succeeds returning the
405 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
406 (setting <<bfd_error>>).
408 Calls @var{pread_func} to request @var{nbytes} of data from
409 @var{stream} starting at @var{offset} (e.g., via a call to
410 <<bfd_read>>). @var{pread_func} either succeeds returning the
411 number of bytes read (which can be less than @var{nbytes} when
412 end-of-file), or fails returning -1 (setting <<bfd_error>>).
414 Calls @var{close_func} when the BFD is later closed using
415 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
416 fails returning -1 (setting <<bfd_error>>).
418 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
419 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
420 on success, or returns -1 on failure (setting <<bfd_error>>).
422 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
423 occurred. Possible errors are <<bfd_error_no_memory>>,
424 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
428 struct opncls
430 void *stream;
431 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
432 file_ptr nbytes, file_ptr offset);
433 int (*close) (struct bfd *abfd, void *stream);
434 int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
435 file_ptr where;
438 static file_ptr
439 opncls_btell (struct bfd *abfd)
441 struct opncls *vec = (struct opncls *) abfd->iostream;
442 return vec->where;
445 static int
446 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
448 struct opncls *vec = (struct opncls *) abfd->iostream;
449 switch (whence)
451 case SEEK_SET: vec->where = offset; break;
452 case SEEK_CUR: vec->where += offset; break;
453 case SEEK_END: return -1;
455 return 0;
458 static file_ptr
459 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
461 struct opncls *vec = (struct opncls *) abfd->iostream;
462 file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
463 if (nread < 0)
464 return nread;
465 vec->where += nread;
466 return nread;
469 static file_ptr
470 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
471 const void *where ATTRIBUTE_UNUSED,
472 file_ptr nbytes ATTRIBUTE_UNUSED)
474 return -1;
477 static int
478 opncls_bclose (struct bfd *abfd)
480 struct opncls *vec = (struct opncls *) abfd->iostream;
481 /* Since the VEC's memory is bound to the bfd deleting the bfd will
482 free it. */
483 int status = 0;
484 if (vec->close != NULL)
485 status = (vec->close) (abfd, vec->stream);
486 abfd->iostream = NULL;
487 return status;
490 static int
491 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
493 return 0;
496 static int
497 opncls_bstat (struct bfd *abfd, struct stat *sb)
499 struct opncls *vec = (struct opncls *) abfd->iostream;
501 memset (sb, 0, sizeof (*sb));
502 if (vec->stat == NULL)
503 return 0;
505 return (vec->stat) (abfd, vec->stream, sb);
508 static void *
509 opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
510 void *addr ATTRIBUTE_UNUSED,
511 bfd_size_type len ATTRIBUTE_UNUSED,
512 int prot ATTRIBUTE_UNUSED,
513 int flags ATTRIBUTE_UNUSED,
514 file_ptr offset ATTRIBUTE_UNUSED)
516 return (void *) -1;
519 static const struct bfd_iovec opncls_iovec = {
520 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
521 &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
524 bfd *
525 bfd_openr_iovec (const char *filename, const char *target,
526 void *(*open_p) (struct bfd *, void *),
527 void *open_closure,
528 file_ptr (*pread_p) (struct bfd *, void *, void *,
529 file_ptr, file_ptr),
530 int (*close_p) (struct bfd *, void *),
531 int (*stat_p) (struct bfd *, void *, struct stat *))
533 bfd *nbfd;
534 const bfd_target *target_vec;
535 struct opncls *vec;
536 void *stream;
538 nbfd = _bfd_new_bfd ();
539 if (nbfd == NULL)
540 return NULL;
542 target_vec = bfd_find_target (target, nbfd);
543 if (target_vec == NULL)
545 _bfd_delete_bfd (nbfd);
546 return NULL;
549 nbfd->filename = filename;
550 nbfd->direction = read_direction;
552 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
553 stream = (*open_p) (nbfd, open_closure);
554 if (stream == NULL)
556 _bfd_delete_bfd (nbfd);
557 return NULL;
560 vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));
561 vec->stream = stream;
562 vec->pread = pread_p;
563 vec->close = close_p;
564 vec->stat = stat_p;
566 nbfd->iovec = &opncls_iovec;
567 nbfd->iostream = vec;
569 return nbfd;
572 /* bfd_openw -- open for writing.
573 Returns a pointer to a freshly-allocated BFD on success, or NULL.
575 See comment by bfd_fdopenr before you try to modify this function. */
578 FUNCTION
579 bfd_openw
581 SYNOPSIS
582 bfd *bfd_openw (const char *filename, const char *target);
584 DESCRIPTION
585 Create a BFD, associated with file @var{filename}, using the
586 file format @var{target}, and return a pointer to it.
588 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
589 <<bfd_error_invalid_target>>.
592 bfd *
593 bfd_openw (const char *filename, const char *target)
595 bfd *nbfd;
596 const bfd_target *target_vec;
598 /* nbfd has to point to head of malloc'ed block so that bfd_close may
599 reclaim it correctly. */
600 nbfd = _bfd_new_bfd ();
601 if (nbfd == NULL)
602 return NULL;
604 target_vec = bfd_find_target (target, nbfd);
605 if (target_vec == NULL)
607 _bfd_delete_bfd (nbfd);
608 return NULL;
611 nbfd->filename = filename;
612 nbfd->direction = write_direction;
614 if (bfd_open_file (nbfd) == NULL)
616 /* File not writeable, etc. */
617 bfd_set_error (bfd_error_system_call);
618 _bfd_delete_bfd (nbfd);
619 return NULL;
622 return nbfd;
625 static inline void
626 _maybe_make_executable (bfd * abfd)
628 /* If the file was open for writing and is now executable,
629 make it so. */
630 if (abfd->direction == write_direction
631 && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)
633 struct stat buf;
635 if (stat (abfd->filename, &buf) == 0
636 /* Do not attempt to change non-regular files. This is
637 here especially for configure scripts and kernel builds
638 which run tests with "ld [...] -o /dev/null". */
639 && S_ISREG(buf.st_mode))
641 unsigned int mask = umask (0);
643 umask (mask);
644 chmod (abfd->filename,
645 (0777
646 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
653 FUNCTION
654 bfd_close
656 SYNOPSIS
657 bfd_boolean bfd_close (bfd *abfd);
659 DESCRIPTION
661 Close a BFD. If the BFD was open for writing, then pending
662 operations are completed and the file written out and closed.
663 If the created file is executable, then <<chmod>> is called
664 to mark it as such.
666 All memory attached to the BFD is released.
668 The file descriptor associated with the BFD is closed (even
669 if it was passed in to BFD by <<bfd_fdopenr>>).
671 RETURNS
672 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
676 bfd_boolean
677 bfd_close (bfd *abfd)
679 bfd_boolean ret;
680 bfd *nbfd;
681 bfd *next;
683 if (bfd_write_p (abfd))
685 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
686 return FALSE;
689 /* Close nested archives (if this bfd is a thin archive). */
690 for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
692 next = nbfd->archive_next;
693 bfd_close (nbfd);
696 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
697 return FALSE;
699 ret = abfd->iovec->bclose (abfd);
701 if (ret)
702 _maybe_make_executable (abfd);
704 _bfd_delete_bfd (abfd);
706 return ret;
710 FUNCTION
711 bfd_close_all_done
713 SYNOPSIS
714 bfd_boolean bfd_close_all_done (bfd *);
716 DESCRIPTION
717 Close a BFD. Differs from <<bfd_close>> since it does not
718 complete any pending operations. This routine would be used
719 if the application had just used BFD for swapping and didn't
720 want to use any of the writing code.
722 If the created file is executable, then <<chmod>> is called
723 to mark it as such.
725 All memory attached to the BFD is released.
727 RETURNS
728 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
731 bfd_boolean
732 bfd_close_all_done (bfd *abfd)
734 bfd_boolean ret;
736 ret = bfd_cache_close (abfd);
738 if (ret)
739 _maybe_make_executable (abfd);
741 _bfd_delete_bfd (abfd);
743 return ret;
747 FUNCTION
748 bfd_create
750 SYNOPSIS
751 bfd *bfd_create (const char *filename, bfd *templ);
753 DESCRIPTION
754 Create a new BFD in the manner of <<bfd_openw>>, but without
755 opening a file. The new BFD takes the target from the target
756 used by @var{template}. The format is always set to <<bfd_object>>.
759 bfd *
760 bfd_create (const char *filename, bfd *templ)
762 bfd *nbfd;
764 nbfd = _bfd_new_bfd ();
765 if (nbfd == NULL)
766 return NULL;
767 nbfd->filename = filename;
768 if (templ)
769 nbfd->xvec = templ->xvec;
770 nbfd->direction = no_direction;
771 bfd_set_format (nbfd, bfd_object);
773 return nbfd;
777 FUNCTION
778 bfd_make_writable
780 SYNOPSIS
781 bfd_boolean bfd_make_writable (bfd *abfd);
783 DESCRIPTION
784 Takes a BFD as created by <<bfd_create>> and converts it
785 into one like as returned by <<bfd_openw>>. It does this
786 by converting the BFD to BFD_IN_MEMORY. It's assumed that
787 you will call <<bfd_make_readable>> on this bfd later.
789 RETURNS
790 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
793 bfd_boolean
794 bfd_make_writable (bfd *abfd)
796 struct bfd_in_memory *bim;
798 if (abfd->direction != no_direction)
800 bfd_set_error (bfd_error_invalid_operation);
801 return FALSE;
804 bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
805 if (bim == NULL)
806 return FALSE; /* bfd_error already set. */
807 abfd->iostream = bim;
808 /* bfd_bwrite will grow these as needed. */
809 bim->size = 0;
810 bim->buffer = 0;
812 abfd->flags |= BFD_IN_MEMORY;
813 abfd->iovec = &_bfd_memory_iovec;
814 abfd->origin = 0;
815 abfd->direction = write_direction;
816 abfd->where = 0;
818 return TRUE;
822 FUNCTION
823 bfd_make_readable
825 SYNOPSIS
826 bfd_boolean bfd_make_readable (bfd *abfd);
828 DESCRIPTION
829 Takes a BFD as created by <<bfd_create>> and
830 <<bfd_make_writable>> and converts it into one like as
831 returned by <<bfd_openr>>. It does this by writing the
832 contents out to the memory buffer, then reversing the
833 direction.
835 RETURNS
836 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
838 bfd_boolean
839 bfd_make_readable (bfd *abfd)
841 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
843 bfd_set_error (bfd_error_invalid_operation);
844 return FALSE;
847 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
848 return FALSE;
850 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
851 return FALSE;
853 abfd->arch_info = &bfd_default_arch_struct;
855 abfd->where = 0;
856 abfd->format = bfd_unknown;
857 abfd->my_archive = NULL;
858 abfd->origin = 0;
859 abfd->opened_once = FALSE;
860 abfd->output_has_begun = FALSE;
861 abfd->section_count = 0;
862 abfd->usrdata = NULL;
863 abfd->cacheable = FALSE;
864 abfd->flags = BFD_IN_MEMORY;
865 abfd->mtime_set = FALSE;
867 abfd->target_defaulted = TRUE;
868 abfd->direction = read_direction;
869 abfd->sections = 0;
870 abfd->symcount = 0;
871 abfd->outsymbols = 0;
872 abfd->tdata.any = 0;
874 bfd_section_list_clear (abfd);
875 bfd_check_format (abfd, bfd_object);
877 return TRUE;
881 INTERNAL_FUNCTION
882 bfd_alloc
884 SYNOPSIS
885 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
887 DESCRIPTION
888 Allocate a block of @var{wanted} bytes of memory attached to
889 <<abfd>> and return a pointer to it.
892 void *
893 bfd_alloc (bfd *abfd, bfd_size_type size)
895 void *ret;
897 if (size != (unsigned long) size)
899 bfd_set_error (bfd_error_no_memory);
900 return NULL;
903 ret = objalloc_alloc ((struct objalloc *) abfd->memory, (unsigned long) size);
904 if (ret == NULL)
905 bfd_set_error (bfd_error_no_memory);
906 return ret;
910 INTERNAL_FUNCTION
911 bfd_alloc2
913 SYNOPSIS
914 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
916 DESCRIPTION
917 Allocate a block of @var{nmemb} elements of @var{size} bytes each
918 of memory attached to <<abfd>> and return a pointer to it.
921 void *
922 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
924 void *ret;
926 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
927 && size != 0
928 && nmemb > ~(bfd_size_type) 0 / size)
930 bfd_set_error (bfd_error_no_memory);
931 return NULL;
934 size *= nmemb;
936 if (size != (unsigned long) size)
938 bfd_set_error (bfd_error_no_memory);
939 return NULL;
942 ret = objalloc_alloc ((struct objalloc *) abfd->memory, (unsigned long) size);
943 if (ret == NULL)
944 bfd_set_error (bfd_error_no_memory);
945 return ret;
949 INTERNAL_FUNCTION
950 bfd_zalloc
952 SYNOPSIS
953 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
955 DESCRIPTION
956 Allocate a block of @var{wanted} bytes of zeroed memory
957 attached to <<abfd>> and return a pointer to it.
960 void *
961 bfd_zalloc (bfd *abfd, bfd_size_type size)
963 void *res;
965 res = bfd_alloc (abfd, size);
966 if (res)
967 memset (res, 0, (size_t) size);
968 return res;
972 INTERNAL_FUNCTION
973 bfd_zalloc2
975 SYNOPSIS
976 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
978 DESCRIPTION
979 Allocate a block of @var{nmemb} elements of @var{size} bytes each
980 of zeroed memory attached to <<abfd>> and return a pointer to it.
983 void *
984 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
986 void *res;
988 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
989 && size != 0
990 && nmemb > ~(bfd_size_type) 0 / size)
992 bfd_set_error (bfd_error_no_memory);
993 return NULL;
996 size *= nmemb;
998 res = bfd_alloc (abfd, size);
999 if (res)
1000 memset (res, 0, (size_t) size);
1001 return res;
1004 /* Free a block allocated for a BFD.
1005 Note: Also frees all more recently allocated blocks! */
1007 void
1008 bfd_release (bfd *abfd, void *block)
1010 objalloc_free_block ((struct objalloc *) abfd->memory, block);
1015 GNU Extension: separate debug-info files
1017 The idea here is that a special section called .gnu_debuglink might be
1018 embedded in a binary file, which indicates that some *other* file
1019 contains the real debugging information. This special section contains a
1020 filename and CRC32 checksum, which we read and resolve to another file,
1021 if it exists.
1023 This facilitates "optional" provision of debugging information, without
1024 having to provide two complete copies of every binary object (with and
1025 without debug symbols).
1028 #define GNU_DEBUGLINK ".gnu_debuglink"
1030 FUNCTION
1031 bfd_calc_gnu_debuglink_crc32
1033 SYNOPSIS
1034 unsigned long bfd_calc_gnu_debuglink_crc32
1035 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1037 DESCRIPTION
1038 Computes a CRC value as used in the .gnu_debuglink section.
1039 Advances the previously computed @var{crc} value by computing
1040 and adding in the crc32 for @var{len} bytes of @var{buf}.
1042 RETURNS
1043 Return the updated CRC32 value.
1046 unsigned long
1047 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1048 const unsigned char *buf,
1049 bfd_size_type len)
1051 static const unsigned long crc32_table[256] =
1053 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1054 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1055 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1056 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1057 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1058 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1059 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1060 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1061 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1062 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1063 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1064 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1065 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1066 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1067 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1068 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1069 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1070 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1071 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1072 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1073 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1074 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1075 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1076 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1077 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1078 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1079 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1080 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1081 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1082 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1083 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1084 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1085 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1086 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1087 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1088 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1089 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1090 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1091 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1092 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1093 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1094 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1095 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1096 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1097 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1098 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1099 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1100 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1101 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1102 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1103 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1104 0x2d02ef8d
1106 const unsigned char *end;
1108 crc = ~crc & 0xffffffff;
1109 for (end = buf + len; buf < end; ++ buf)
1110 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1111 return ~crc & 0xffffffff;;
1116 INTERNAL_FUNCTION
1117 get_debug_link_info
1119 SYNOPSIS
1120 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1122 DESCRIPTION
1123 fetch the filename and CRC32 value for any separate debuginfo
1124 associated with @var{abfd}. Return NULL if no such info found,
1125 otherwise return filename and update @var{crc32_out}.
1128 static char *
1129 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1131 asection *sect;
1132 unsigned long crc32;
1133 bfd_byte *contents;
1134 int crc_offset;
1135 char *name;
1137 BFD_ASSERT (abfd);
1138 BFD_ASSERT (crc32_out);
1140 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1142 if (sect == NULL)
1143 return NULL;
1145 if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1147 if (contents != NULL)
1148 free (contents);
1149 return NULL;
1152 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1153 name = (char *) contents;
1154 crc_offset = strlen (name) + 1;
1155 crc_offset = (crc_offset + 3) & ~3;
1157 crc32 = bfd_get_32 (abfd, contents + crc_offset);
1159 *crc32_out = crc32;
1160 return name;
1164 INTERNAL_FUNCTION
1165 separate_debug_file_exists
1167 SYNOPSIS
1168 bfd_boolean separate_debug_file_exists
1169 (char *name, unsigned long crc32);
1171 DESCRIPTION
1172 Checks to see if @var{name} is a file and if its contents
1173 match @var{crc32}.
1176 static bfd_boolean
1177 separate_debug_file_exists (const char *name, const unsigned long crc)
1179 static unsigned char buffer [8 * 1024];
1180 unsigned long file_crc = 0;
1181 FILE *f;
1182 bfd_size_type count;
1184 BFD_ASSERT (name);
1186 f = real_fopen (name, FOPEN_RB);
1187 if (f == NULL)
1188 return FALSE;
1190 while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1191 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1193 fclose (f);
1195 return crc == file_crc;
1200 INTERNAL_FUNCTION
1201 find_separate_debug_file
1203 SYNOPSIS
1204 char *find_separate_debug_file (bfd *abfd);
1206 DESCRIPTION
1207 Searches @var{abfd} for a reference to separate debugging
1208 information, scans various locations in the filesystem, including
1209 the file tree rooted at @var{debug_file_directory}, and returns a
1210 filename of such debugging information if the file is found and has
1211 matching CRC32. Returns NULL if no reference to debugging file
1212 exists, or file cannot be found.
1215 static char *
1216 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1218 char *base;
1219 char *dir;
1220 char *debugfile;
1221 char *canon_dir;
1222 unsigned long crc32;
1223 size_t dirlen;
1224 size_t canon_dirlen;
1226 BFD_ASSERT (abfd);
1227 if (debug_file_directory == NULL)
1228 debug_file_directory = ".";
1230 /* BFD may have been opened from a stream. */
1231 if (abfd->filename == NULL)
1233 bfd_set_error (bfd_error_invalid_operation);
1234 return NULL;
1237 base = get_debug_link_info (abfd, & crc32);
1238 if (base == NULL)
1239 return NULL;
1241 if (base[0] == '\0')
1243 free (base);
1244 bfd_set_error (bfd_error_no_debug_section);
1245 return NULL;
1248 for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1249 if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1250 break;
1252 dir = (char *) bfd_malloc (dirlen + 1);
1253 if (dir == NULL)
1255 free (base);
1256 return NULL;
1258 memcpy (dir, abfd->filename, dirlen);
1259 dir[dirlen] = '\0';
1261 /* Compute the canonical name of the bfd object with all symbolic links
1262 resolved, for use in the global debugfile directory. */
1263 canon_dir = lrealpath (abfd->filename);
1264 for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1265 if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1266 break;
1267 canon_dir[canon_dirlen] = '\0';
1269 debugfile = (char *)
1270 bfd_malloc (strlen (debug_file_directory) + 1
1271 + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1272 + strlen (".debug/")
1273 + strlen (base)
1274 + 1);
1275 if (debugfile == NULL)
1277 free (base);
1278 free (dir);
1279 free (canon_dir);
1280 return NULL;
1283 /* First try in the same directory as the original file: */
1284 strcpy (debugfile, dir);
1285 strcat (debugfile, base);
1287 if (separate_debug_file_exists (debugfile, crc32))
1289 free (base);
1290 free (dir);
1291 free (canon_dir);
1292 return debugfile;
1295 /* Then try in a subdirectory called .debug. */
1296 strcpy (debugfile, dir);
1297 strcat (debugfile, ".debug/");
1298 strcat (debugfile, base);
1300 if (separate_debug_file_exists (debugfile, crc32))
1302 free (base);
1303 free (dir);
1304 free (canon_dir);
1305 return debugfile;
1308 /* Then try in the global debugfile directory. */
1309 strcpy (debugfile, debug_file_directory);
1310 dirlen = strlen (debug_file_directory) - 1;
1311 if (dirlen > 0
1312 && debug_file_directory[dirlen] != '/'
1313 && canon_dir[0] != '/')
1314 strcat (debugfile, "/");
1315 strcat (debugfile, canon_dir);
1316 strcat (debugfile, base);
1318 if (separate_debug_file_exists (debugfile, crc32))
1320 free (base);
1321 free (dir);
1322 free (canon_dir);
1323 return debugfile;
1326 free (debugfile);
1327 free (base);
1328 free (dir);
1329 free (canon_dir);
1330 return NULL;
1335 FUNCTION
1336 bfd_follow_gnu_debuglink
1338 SYNOPSIS
1339 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1341 DESCRIPTION
1343 Takes a BFD and searches it for a .gnu_debuglink section. If this
1344 section is found, it examines the section for the name and checksum
1345 of a '.debug' file containing auxiliary debugging information. It
1346 then searches the filesystem for this .debug file in some standard
1347 locations, including the directory tree rooted at @var{dir}, and if
1348 found returns the full filename.
1350 If @var{dir} is NULL, it will search a default path configured into
1351 libbfd at build time. [XXX this feature is not currently
1352 implemented].
1354 RETURNS
1355 <<NULL>> on any errors or failure to locate the .debug file,
1356 otherwise a pointer to a heap-allocated string containing the
1357 filename. The caller is responsible for freeing this string.
1360 char *
1361 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1363 return find_separate_debug_file (abfd, dir);
1367 FUNCTION
1368 bfd_create_gnu_debuglink_section
1370 SYNOPSIS
1371 struct bfd_section *bfd_create_gnu_debuglink_section
1372 (bfd *abfd, const char *filename);
1374 DESCRIPTION
1376 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized
1377 to be big enough to contain a link to the specified @var{filename}.
1379 RETURNS
1380 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is
1381 returned and bfd_error is set.
1384 asection *
1385 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1387 asection *sect;
1388 bfd_size_type debuglink_size;
1389 flagword flags;
1391 if (abfd == NULL || filename == NULL)
1393 bfd_set_error (bfd_error_invalid_operation);
1394 return NULL;
1397 /* Strip off any path components in filename. */
1398 filename = lbasename (filename);
1400 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1401 if (sect)
1403 /* Section already exists. */
1404 bfd_set_error (bfd_error_invalid_operation);
1405 return NULL;
1408 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1409 sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1410 if (sect == NULL)
1411 return NULL;
1413 debuglink_size = strlen (filename) + 1;
1414 debuglink_size += 3;
1415 debuglink_size &= ~3;
1416 debuglink_size += 4;
1418 if (! bfd_set_section_size (abfd, sect, debuglink_size))
1419 /* XXX Should we delete the section from the bfd ? */
1420 return NULL;
1422 return sect;
1427 FUNCTION
1428 bfd_fill_in_gnu_debuglink_section
1430 SYNOPSIS
1431 bfd_boolean bfd_fill_in_gnu_debuglink_section
1432 (bfd *abfd, struct bfd_section *sect, const char *filename);
1434 DESCRIPTION
1436 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1437 and fills in the contents of the section to contain a link to the
1438 specified @var{filename}. The filename should be relative to the
1439 current directory.
1441 RETURNS
1442 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1443 and bfd_error is set.
1446 bfd_boolean
1447 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1448 struct bfd_section *sect,
1449 const char *filename)
1451 bfd_size_type debuglink_size;
1452 unsigned long crc32;
1453 char * contents;
1454 bfd_size_type crc_offset;
1455 FILE * handle;
1456 static unsigned char buffer[8 * 1024];
1457 size_t count;
1458 size_t filelen;
1460 if (abfd == NULL || sect == NULL || filename == NULL)
1462 bfd_set_error (bfd_error_invalid_operation);
1463 return FALSE;
1466 /* Make sure that we can read the file.
1467 XXX - Should we attempt to locate the debug info file using the same
1468 algorithm as gdb ? At the moment, since we are creating the
1469 .gnu_debuglink section, we insist upon the user providing us with a
1470 correct-for-section-creation-time path, but this need not conform to
1471 the gdb location algorithm. */
1472 handle = real_fopen (filename, FOPEN_RB);
1473 if (handle == NULL)
1475 bfd_set_error (bfd_error_system_call);
1476 return FALSE;
1479 crc32 = 0;
1480 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1481 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1482 fclose (handle);
1484 /* Strip off any path components in filename,
1485 now that we no longer need them. */
1486 filename = lbasename (filename);
1488 filelen = strlen (filename);
1489 debuglink_size = filelen + 1;
1490 debuglink_size += 3;
1491 debuglink_size &= ~3;
1492 debuglink_size += 4;
1494 contents = (char *) bfd_malloc (debuglink_size);
1495 if (contents == NULL)
1497 /* XXX Should we delete the section from the bfd ? */
1498 return FALSE;
1501 crc_offset = debuglink_size - 4;
1502 memcpy (contents, filename, filelen);
1503 memset (contents + filelen, 0, crc_offset - filelen);
1505 bfd_put_32 (abfd, crc32, contents + crc_offset);
1507 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1509 /* XXX Should we delete the section from the bfd ? */
1510 free (contents);
1511 return FALSE;
1514 return TRUE;