2007-02-13 Paolo Bonzini <bonzini@gnu.org>
[binutils.git] / bfd / opncls.c
blob4002f5f1bba384d130dbbb93982a7e8bbcdc8661
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
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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "objalloc.h"
27 #include "libbfd.h"
28 #include "libiberty.h"
30 #ifndef S_IXUSR
31 #define S_IXUSR 0100 /* Execute by owner. */
32 #endif
33 #ifndef S_IXGRP
34 #define S_IXGRP 0010 /* Execute by group. */
35 #endif
36 #ifndef S_IXOTH
37 #define S_IXOTH 0001 /* Execute by others. */
38 #endif
40 /* Counter used to initialize the bfd identifier. */
42 static unsigned int _bfd_id_counter = 0;
44 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
45 if we do that we can't use fcntl. */
47 /* Return a new BFD. All BFD's are allocated through this routine. */
49 bfd *
50 _bfd_new_bfd (void)
52 bfd *nbfd;
54 nbfd = bfd_zmalloc (sizeof (bfd));
55 if (nbfd == NULL)
56 return NULL;
58 nbfd->id = _bfd_id_counter++;
60 nbfd->memory = objalloc_create ();
61 if (nbfd->memory == NULL)
63 bfd_set_error (bfd_error_no_memory);
64 free (nbfd);
65 return NULL;
68 nbfd->arch_info = &bfd_default_arch_struct;
70 nbfd->direction = no_direction;
71 nbfd->iostream = NULL;
72 nbfd->where = 0;
73 if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
74 sizeof (struct section_hash_entry), 251))
76 free (nbfd);
77 return NULL;
79 nbfd->sections = NULL;
80 nbfd->section_last = NULL;
81 nbfd->format = bfd_unknown;
82 nbfd->my_archive = NULL;
83 nbfd->origin = 0;
84 nbfd->opened_once = FALSE;
85 nbfd->output_has_begun = FALSE;
86 nbfd->section_count = 0;
87 nbfd->usrdata = NULL;
88 nbfd->cacheable = FALSE;
89 nbfd->flags = BFD_NO_FLAGS;
90 nbfd->mtime_set = FALSE;
92 return nbfd;
95 /* Allocate a new BFD as a member of archive OBFD. */
97 bfd *
98 _bfd_new_bfd_contained_in (bfd *obfd)
100 bfd *nbfd;
102 nbfd = _bfd_new_bfd ();
103 if (nbfd == NULL)
104 return NULL;
105 nbfd->xvec = obfd->xvec;
106 nbfd->iovec = obfd->iovec;
107 nbfd->my_archive = obfd;
108 nbfd->direction = read_direction;
109 nbfd->target_defaulted = obfd->target_defaulted;
110 return nbfd;
113 /* Delete a BFD. */
115 void
116 _bfd_delete_bfd (bfd *abfd)
118 if (abfd->memory)
120 bfd_hash_table_free (&abfd->section_htab);
121 objalloc_free ((struct objalloc *) abfd->memory);
123 free (abfd);
126 /* Free objalloc memory. */
128 bfd_boolean
129 _bfd_free_cached_info (bfd *abfd)
131 if (abfd->memory)
133 bfd_hash_table_free (&abfd->section_htab);
134 objalloc_free ((struct objalloc *) abfd->memory);
136 abfd->sections = NULL;
137 abfd->section_last = NULL;
138 abfd->outsymbols = NULL;
139 abfd->tdata.any = NULL;
140 abfd->usrdata = NULL;
141 abfd->memory = NULL;
144 return TRUE;
148 SECTION
149 Opening and closing BFDs
151 SUBSECTION
152 Functions for opening and closing
156 FUNCTION
157 bfd_fopen
159 SYNOPSIS
160 bfd *bfd_fopen (const char *filename, const char *target,
161 const char *mode, int fd);
163 DESCRIPTION
164 Open the file @var{filename} with the target @var{target}.
165 Return a pointer to the created BFD. If @var{fd} is not -1,
166 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
167 is used. @var{mode} is passed directly to <<fopen>> or
168 <<fdopen>>.
170 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
171 that function.
173 The new BFD is marked as cacheable iff @var{fd} is -1.
175 If <<NULL>> is returned then an error has occured. Possible errors
176 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
177 <<system_call>> error.
180 bfd *
181 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
183 bfd *nbfd;
184 const bfd_target *target_vec;
186 nbfd = _bfd_new_bfd ();
187 if (nbfd == NULL)
188 return NULL;
190 target_vec = bfd_find_target (target, nbfd);
191 if (target_vec == NULL)
193 _bfd_delete_bfd (nbfd);
194 return NULL;
197 #ifdef HAVE_FDOPEN
198 if (fd != -1)
199 nbfd->iostream = fdopen (fd, mode);
200 else
201 #endif
202 nbfd->iostream = real_fopen (filename, mode);
203 if (nbfd->iostream == NULL)
205 bfd_set_error (bfd_error_system_call);
206 _bfd_delete_bfd (nbfd);
207 return NULL;
210 /* OK, put everything where it belongs. */
211 nbfd->filename = filename;
213 /* Figure out whether the user is opening the file for reading,
214 writing, or both, by looking at the MODE argument. */
215 if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
216 && mode[1] == '+')
217 nbfd->direction = both_direction;
218 else if (mode[0] == 'r')
219 nbfd->direction = read_direction;
220 else
221 nbfd->direction = write_direction;
223 if (! bfd_cache_init (nbfd))
225 _bfd_delete_bfd (nbfd);
226 return NULL;
228 nbfd->opened_once = TRUE;
229 /* If we opened the file by name, mark it cacheable; we can close it
230 and reopen it later. However, if a file descriptor was provided,
231 then it may have been opened with special flags that make it
232 unsafe to close and reopen the file. */
233 if (fd == -1)
234 bfd_set_cacheable (nbfd, TRUE);
236 return nbfd;
240 FUNCTION
241 bfd_openr
243 SYNOPSIS
244 bfd *bfd_openr (const char *filename, const char *target);
246 DESCRIPTION
247 Open the file @var{filename} (using <<fopen>>) with the target
248 @var{target}. Return a pointer to the created BFD.
250 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
251 that function.
253 If <<NULL>> is returned then an error has occured. Possible errors
254 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
255 <<system_call>> error.
258 bfd *
259 bfd_openr (const char *filename, const char *target)
261 return bfd_fopen (filename, target, FOPEN_RB, -1);
264 /* Don't try to `optimize' this function:
266 o - We lock using stack space so that interrupting the locking
267 won't cause a storage leak.
268 o - We open the file stream last, since we don't want to have to
269 close it if anything goes wrong. Closing the stream means closing
270 the file descriptor too, even though we didn't open it. */
272 FUNCTION
273 bfd_fdopenr
275 SYNOPSIS
276 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
278 DESCRIPTION
279 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
280 <<fopen>>. It opens a BFD on a file already described by the
281 @var{fd} supplied.
283 When the file is later <<bfd_close>>d, the file descriptor will
284 be closed. If the caller desires that this file descriptor be
285 cached by BFD (opened as needed, closed as needed to free
286 descriptors for other opens), with the supplied @var{fd} used as
287 an initial file descriptor (but subject to closure at any time),
288 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
289 is to assume no caching; the file descriptor will remain open
290 until <<bfd_close>>, and will not be affected by BFD operations
291 on other files.
293 Possible errors are <<bfd_error_no_memory>>,
294 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
297 bfd *
298 bfd_fdopenr (const char *filename, const char *target, int fd)
300 const char *mode;
301 #if defined(HAVE_FCNTL) && defined(F_GETFL)
302 int fdflags;
303 #endif
305 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
306 mode = FOPEN_RUB; /* Assume full access. */
307 #else
308 fdflags = fcntl (fd, F_GETFL, NULL);
309 if (fdflags == -1)
311 bfd_set_error (bfd_error_system_call);
312 return NULL;
315 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
316 switch (fdflags & (O_ACCMODE))
318 case O_RDONLY: mode = FOPEN_RB; break;
319 case O_WRONLY: mode = FOPEN_RUB; break;
320 case O_RDWR: mode = FOPEN_RUB; break;
321 default: abort ();
323 #endif
325 return bfd_fopen (filename, target, mode, fd);
329 FUNCTION
330 bfd_openstreamr
332 SYNOPSIS
333 bfd *bfd_openstreamr (const char *, const char *, void *);
335 DESCRIPTION
337 Open a BFD for read access on an existing stdio stream. When
338 the BFD is passed to <<bfd_close>>, the stream will be closed.
341 bfd *
342 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
344 FILE *stream = streamarg;
345 bfd *nbfd;
346 const bfd_target *target_vec;
348 nbfd = _bfd_new_bfd ();
349 if (nbfd == NULL)
350 return NULL;
352 target_vec = bfd_find_target (target, nbfd);
353 if (target_vec == NULL)
355 _bfd_delete_bfd (nbfd);
356 return NULL;
359 nbfd->iostream = stream;
360 nbfd->filename = filename;
361 nbfd->direction = read_direction;
363 if (! bfd_cache_init (nbfd))
365 _bfd_delete_bfd (nbfd);
366 return NULL;
369 return nbfd;
373 FUNCTION
374 bfd_openr_iovec
376 SYNOPSIS
377 bfd *bfd_openr_iovec (const char *filename, const char *target,
378 void *(*open) (struct bfd *nbfd,
379 void *open_closure),
380 void *open_closure,
381 file_ptr (*pread) (struct bfd *nbfd,
382 void *stream,
383 void *buf,
384 file_ptr nbytes,
385 file_ptr offset),
386 int (*close) (struct bfd *nbfd,
387 void *stream),
388 int (*stat) (struct bfd *abfd,
389 void *stream,
390 struct stat *sb));
392 DESCRIPTION
394 Create and return a BFD backed by a read-only @var{stream}.
395 The @var{stream} is created using @var{open}, accessed using
396 @var{pread} and destroyed using @var{close}.
398 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
399 that function.
401 Calls @var{open} (which can call <<bfd_zalloc>> and
402 <<bfd_get_filename>>) to obtain the read-only stream backing
403 the BFD. @var{open} either succeeds returning the
404 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
405 (setting <<bfd_error>>).
407 Calls @var{pread} to request @var{nbytes} of data from
408 @var{stream} starting at @var{offset} (e.g., via a call to
409 <<bfd_read>>). @var{pread} either succeeds returning the
410 number of bytes read (which can be less than @var{nbytes} when
411 end-of-file), or fails returning -1 (setting <<bfd_error>>).
413 Calls @var{close} when the BFD is later closed using
414 <<bfd_close>>. @var{close} either succeeds returning 0, or
415 fails returning -1 (setting <<bfd_error>>).
417 Calls @var{stat} to fill in a stat structure for bfd_stat,
418 bfd_get_size, and bfd_get_mtime calls. @var{stat} returns 0
419 on success, or returns -1 on failure (setting <<bfd_error>>).
421 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
422 occurred. Possible errors are <<bfd_error_no_memory>>,
423 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
427 struct opncls
429 void *stream;
430 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
431 file_ptr nbytes, file_ptr offset);
432 int (*close) (struct bfd *abfd, void *stream);
433 int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
434 file_ptr where;
437 static file_ptr
438 opncls_btell (struct bfd *abfd)
440 struct opncls *vec = abfd->iostream;
441 return vec->where;
444 static int
445 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
447 struct opncls *vec = abfd->iostream;
448 switch (whence)
450 case SEEK_SET: vec->where = offset; break;
451 case SEEK_CUR: vec->where += offset; break;
452 case SEEK_END: return -1;
454 return 0;
457 static file_ptr
458 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
460 struct opncls *vec = abfd->iostream;
461 file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
462 if (nread < 0)
463 return nread;
464 vec->where += nread;
465 return nread;
468 static file_ptr
469 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
470 const void *where ATTRIBUTE_UNUSED,
471 file_ptr nbytes ATTRIBUTE_UNUSED)
473 return -1;
476 static int
477 opncls_bclose (struct bfd *abfd)
479 struct opncls *vec = abfd->iostream;
480 /* Since the VEC's memory is bound to the bfd deleting the bfd will
481 free it. */
482 int status = 0;
483 if (vec->close != NULL)
484 status = (vec->close) (abfd, vec->stream);
485 abfd->iostream = NULL;
486 return status;
489 static int
490 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
492 return 0;
495 static int
496 opncls_bstat (struct bfd *abfd, struct stat *sb)
498 struct opncls *vec = abfd->iostream;
500 memset (sb, 0, sizeof (*sb));
501 if (vec->stat == NULL)
502 return 0;
504 return (vec->stat) (abfd, vec->stream, sb);
507 static const struct bfd_iovec opncls_iovec = {
508 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
509 &opncls_bclose, &opncls_bflush, &opncls_bstat
512 bfd *
513 bfd_openr_iovec (const char *filename, const char *target,
514 void *(*open) (struct bfd *nbfd,
515 void *open_closure),
516 void *open_closure,
517 file_ptr (*pread) (struct bfd *abfd,
518 void *stream,
519 void *buf,
520 file_ptr nbytes,
521 file_ptr offset),
522 int (*close) (struct bfd *nbfd,
523 void *stream),
524 int (*stat) (struct bfd *abfd,
525 void *stream,
526 struct stat *sb))
528 bfd *nbfd;
529 const bfd_target *target_vec;
530 struct opncls *vec;
531 void *stream;
533 nbfd = _bfd_new_bfd ();
534 if (nbfd == NULL)
535 return NULL;
537 target_vec = bfd_find_target (target, nbfd);
538 if (target_vec == NULL)
540 _bfd_delete_bfd (nbfd);
541 return NULL;
544 nbfd->filename = filename;
545 nbfd->direction = read_direction;
547 stream = open (nbfd, open_closure);
548 if (stream == NULL)
550 _bfd_delete_bfd (nbfd);
551 return NULL;
554 vec = bfd_zalloc (nbfd, sizeof (struct opncls));
555 vec->stream = stream;
556 vec->pread = pread;
557 vec->close = close;
558 vec->stat = stat;
560 nbfd->iovec = &opncls_iovec;
561 nbfd->iostream = vec;
563 return nbfd;
566 /* bfd_openw -- open for writing.
567 Returns a pointer to a freshly-allocated BFD on success, or NULL.
569 See comment by bfd_fdopenr before you try to modify this function. */
572 FUNCTION
573 bfd_openw
575 SYNOPSIS
576 bfd *bfd_openw (const char *filename, const char *target);
578 DESCRIPTION
579 Create a BFD, associated with file @var{filename}, using the
580 file format @var{target}, and return a pointer to it.
582 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
583 <<bfd_error_invalid_target>>.
586 bfd *
587 bfd_openw (const char *filename, const char *target)
589 bfd *nbfd;
590 const bfd_target *target_vec;
592 /* nbfd has to point to head of malloc'ed block so that bfd_close may
593 reclaim it correctly. */
594 nbfd = _bfd_new_bfd ();
595 if (nbfd == NULL)
596 return NULL;
598 target_vec = bfd_find_target (target, nbfd);
599 if (target_vec == NULL)
601 _bfd_delete_bfd (nbfd);
602 return NULL;
605 nbfd->filename = filename;
606 nbfd->direction = write_direction;
608 if (bfd_open_file (nbfd) == NULL)
610 /* File not writeable, etc. */
611 bfd_set_error (bfd_error_system_call);
612 _bfd_delete_bfd (nbfd);
613 return NULL;
616 return nbfd;
621 FUNCTION
622 bfd_close
624 SYNOPSIS
625 bfd_boolean bfd_close (bfd *abfd);
627 DESCRIPTION
629 Close a BFD. If the BFD was open for writing, then pending
630 operations are completed and the file written out and closed.
631 If the created file is executable, then <<chmod>> is called
632 to mark it as such.
634 All memory attached to the BFD is released.
636 The file descriptor associated with the BFD is closed (even
637 if it was passed in to BFD by <<bfd_fdopenr>>).
639 RETURNS
640 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
644 bfd_boolean
645 bfd_close (bfd *abfd)
647 bfd_boolean ret;
649 if (bfd_write_p (abfd))
651 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
652 return FALSE;
655 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
656 return FALSE;
658 /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
659 vector. */
660 if (!(abfd->flags & BFD_IN_MEMORY))
661 ret = abfd->iovec->bclose (abfd);
662 else
663 ret = TRUE;
665 /* If the file was open for writing and is now executable,
666 make it so. */
667 if (ret
668 && abfd->direction == write_direction
669 && abfd->flags & EXEC_P)
671 struct stat buf;
673 if (stat (abfd->filename, &buf) == 0)
675 unsigned int mask = umask (0);
677 umask (mask);
678 chmod (abfd->filename,
679 (0777
680 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
684 _bfd_delete_bfd (abfd);
686 return ret;
690 FUNCTION
691 bfd_close_all_done
693 SYNOPSIS
694 bfd_boolean bfd_close_all_done (bfd *);
696 DESCRIPTION
697 Close a BFD. Differs from <<bfd_close>> since it does not
698 complete any pending operations. This routine would be used
699 if the application had just used BFD for swapping and didn't
700 want to use any of the writing code.
702 If the created file is executable, then <<chmod>> is called
703 to mark it as such.
705 All memory attached to the BFD is released.
707 RETURNS
708 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
711 bfd_boolean
712 bfd_close_all_done (bfd *abfd)
714 bfd_boolean ret;
716 ret = bfd_cache_close (abfd);
718 /* If the file was open for writing and is now executable,
719 make it so. */
720 if (ret
721 && abfd->direction == write_direction
722 && abfd->flags & EXEC_P)
724 struct stat buf;
726 if (stat (abfd->filename, &buf) == 0)
728 unsigned int mask = umask (0);
730 umask (mask);
731 chmod (abfd->filename,
732 (0777
733 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
737 _bfd_delete_bfd (abfd);
739 return ret;
743 FUNCTION
744 bfd_create
746 SYNOPSIS
747 bfd *bfd_create (const char *filename, bfd *templ);
749 DESCRIPTION
750 Create a new BFD in the manner of <<bfd_openw>>, but without
751 opening a file. The new BFD takes the target from the target
752 used by @var{template}. The format is always set to <<bfd_object>>.
755 bfd *
756 bfd_create (const char *filename, bfd *templ)
758 bfd *nbfd;
760 nbfd = _bfd_new_bfd ();
761 if (nbfd == NULL)
762 return NULL;
763 nbfd->filename = filename;
764 if (templ)
765 nbfd->xvec = templ->xvec;
766 nbfd->direction = no_direction;
767 bfd_set_format (nbfd, bfd_object);
769 return nbfd;
773 FUNCTION
774 bfd_make_writable
776 SYNOPSIS
777 bfd_boolean bfd_make_writable (bfd *abfd);
779 DESCRIPTION
780 Takes a BFD as created by <<bfd_create>> and converts it
781 into one like as returned by <<bfd_openw>>. It does this
782 by converting the BFD to BFD_IN_MEMORY. It's assumed that
783 you will call <<bfd_make_readable>> on this bfd later.
785 RETURNS
786 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
789 bfd_boolean
790 bfd_make_writable (bfd *abfd)
792 struct bfd_in_memory *bim;
794 if (abfd->direction != no_direction)
796 bfd_set_error (bfd_error_invalid_operation);
797 return FALSE;
800 bim = bfd_malloc (sizeof (struct bfd_in_memory));
801 abfd->iostream = bim;
802 /* bfd_bwrite will grow these as needed. */
803 bim->size = 0;
804 bim->buffer = 0;
806 abfd->flags |= BFD_IN_MEMORY;
807 abfd->direction = write_direction;
808 abfd->where = 0;
810 return TRUE;
814 FUNCTION
815 bfd_make_readable
817 SYNOPSIS
818 bfd_boolean bfd_make_readable (bfd *abfd);
820 DESCRIPTION
821 Takes a BFD as created by <<bfd_create>> and
822 <<bfd_make_writable>> and converts it into one like as
823 returned by <<bfd_openr>>. It does this by writing the
824 contents out to the memory buffer, then reversing the
825 direction.
827 RETURNS
828 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
830 bfd_boolean
831 bfd_make_readable (bfd *abfd)
833 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
835 bfd_set_error (bfd_error_invalid_operation);
836 return FALSE;
839 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
840 return FALSE;
842 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
843 return FALSE;
846 abfd->arch_info = &bfd_default_arch_struct;
848 abfd->where = 0;
849 abfd->format = bfd_unknown;
850 abfd->my_archive = NULL;
851 abfd->origin = 0;
852 abfd->opened_once = FALSE;
853 abfd->output_has_begun = FALSE;
854 abfd->section_count = 0;
855 abfd->usrdata = NULL;
856 abfd->cacheable = FALSE;
857 abfd->flags = BFD_IN_MEMORY;
858 abfd->mtime_set = FALSE;
860 abfd->target_defaulted = TRUE;
861 abfd->direction = read_direction;
862 abfd->sections = 0;
863 abfd->symcount = 0;
864 abfd->outsymbols = 0;
865 abfd->tdata.any = 0;
867 bfd_section_list_clear (abfd);
868 bfd_check_format (abfd, bfd_object);
870 return TRUE;
874 INTERNAL_FUNCTION
875 bfd_alloc
877 SYNOPSIS
878 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
880 DESCRIPTION
881 Allocate a block of @var{wanted} bytes of memory attached to
882 <<abfd>> and return a pointer to it.
885 void *
886 bfd_alloc (bfd *abfd, bfd_size_type size)
888 void *ret;
890 if (size != (unsigned long) size)
892 bfd_set_error (bfd_error_no_memory);
893 return NULL;
896 ret = objalloc_alloc (abfd->memory, (unsigned long) size);
897 if (ret == NULL)
898 bfd_set_error (bfd_error_no_memory);
899 return ret;
903 INTERNAL_FUNCTION
904 bfd_alloc2
906 SYNOPSIS
907 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
909 DESCRIPTION
910 Allocate a block of @var{nmemb} elements of @var{size} bytes each
911 of memory attached to <<abfd>> and return a pointer to it.
914 void *
915 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
917 void *ret;
919 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
920 && size != 0
921 && nmemb > ~(bfd_size_type) 0 / size)
923 bfd_set_error (bfd_error_no_memory);
924 return NULL;
927 size *= nmemb;
929 if (size != (unsigned long) size)
931 bfd_set_error (bfd_error_no_memory);
932 return NULL;
935 ret = objalloc_alloc (abfd->memory, (unsigned long) size);
936 if (ret == NULL)
937 bfd_set_error (bfd_error_no_memory);
938 return ret;
942 INTERNAL_FUNCTION
943 bfd_zalloc
945 SYNOPSIS
946 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
948 DESCRIPTION
949 Allocate a block of @var{wanted} bytes of zeroed memory
950 attached to <<abfd>> and return a pointer to it.
953 void *
954 bfd_zalloc (bfd *abfd, bfd_size_type size)
956 void *res;
958 res = bfd_alloc (abfd, size);
959 if (res)
960 memset (res, 0, (size_t) size);
961 return res;
965 INTERNAL_FUNCTION
966 bfd_zalloc2
968 SYNOPSIS
969 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
971 DESCRIPTION
972 Allocate a block of @var{nmemb} elements of @var{size} bytes each
973 of zeroed memory attached to <<abfd>> and return a pointer to it.
976 void *
977 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
979 void *res;
981 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
982 && size != 0
983 && nmemb > ~(bfd_size_type) 0 / size)
985 bfd_set_error (bfd_error_no_memory);
986 return NULL;
989 size *= nmemb;
991 res = bfd_alloc (abfd, size);
992 if (res)
993 memset (res, 0, (size_t) size);
994 return res;
997 /* Free a block allocated for a BFD.
998 Note: Also frees all more recently allocated blocks! */
1000 void
1001 bfd_release (bfd *abfd, void *block)
1003 objalloc_free_block ((struct objalloc *) abfd->memory, block);
1008 GNU Extension: separate debug-info files
1010 The idea here is that a special section called .gnu_debuglink might be
1011 embedded in a binary file, which indicates that some *other* file
1012 contains the real debugging information. This special section contains a
1013 filename and CRC32 checksum, which we read and resolve to another file,
1014 if it exists.
1016 This facilitates "optional" provision of debugging information, without
1017 having to provide two complete copies of every binary object (with and
1018 without debug symbols).
1021 #define GNU_DEBUGLINK ".gnu_debuglink"
1023 FUNCTION
1024 bfd_calc_gnu_debuglink_crc32
1026 SYNOPSIS
1027 unsigned long bfd_calc_gnu_debuglink_crc32
1028 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1030 DESCRIPTION
1031 Computes a CRC value as used in the .gnu_debuglink section.
1032 Advances the previously computed @var{crc} value by computing
1033 and adding in the crc32 for @var{len} bytes of @var{buf}.
1035 RETURNS
1036 Return the updated CRC32 value.
1039 unsigned long
1040 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1041 const unsigned char *buf,
1042 bfd_size_type len)
1044 static const unsigned long crc32_table[256] =
1046 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1047 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1048 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1049 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1050 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1051 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1052 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1053 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1054 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1055 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1056 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1057 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1058 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1059 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1060 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1061 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1062 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1063 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1064 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1065 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1066 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1067 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1068 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1069 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1070 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1071 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1072 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1073 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1074 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1075 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1076 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1077 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1078 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1079 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1080 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1081 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1082 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1083 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1084 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1085 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1086 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1087 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1088 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1089 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1090 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1091 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1092 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1093 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1094 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1095 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1096 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1097 0x2d02ef8d
1099 const unsigned char *end;
1101 crc = ~crc & 0xffffffff;
1102 for (end = buf + len; buf < end; ++ buf)
1103 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1104 return ~crc & 0xffffffff;;
1109 INTERNAL_FUNCTION
1110 get_debug_link_info
1112 SYNOPSIS
1113 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1115 DESCRIPTION
1116 fetch the filename and CRC32 value for any separate debuginfo
1117 associated with @var{abfd}. Return NULL if no such info found,
1118 otherwise return filename and update @var{crc32_out}.
1121 static char *
1122 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1124 asection *sect;
1125 unsigned long crc32;
1126 bfd_byte *contents;
1127 int crc_offset;
1128 char *name;
1130 BFD_ASSERT (abfd);
1131 BFD_ASSERT (crc32_out);
1133 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1135 if (sect == NULL)
1136 return NULL;
1138 if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1140 if (contents != NULL)
1141 free (contents);
1142 return NULL;
1145 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1146 name = (char *) contents;
1147 crc_offset = strlen (name) + 1;
1148 crc_offset = (crc_offset + 3) & ~3;
1150 crc32 = bfd_get_32 (abfd, contents + crc_offset);
1152 *crc32_out = crc32;
1153 return name;
1157 INTERNAL_FUNCTION
1158 separate_debug_file_exists
1160 SYNOPSIS
1161 bfd_boolean separate_debug_file_exists
1162 (char *name, unsigned long crc32);
1164 DESCRIPTION
1165 Checks to see if @var{name} is a file and if its contents
1166 match @var{crc32}.
1169 static bfd_boolean
1170 separate_debug_file_exists (const char *name, const unsigned long crc)
1172 static unsigned char buffer [8 * 1024];
1173 unsigned long file_crc = 0;
1174 int fd;
1175 bfd_size_type count;
1177 BFD_ASSERT (name);
1179 fd = open (name, O_RDONLY);
1180 if (fd < 0)
1181 return FALSE;
1183 while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1184 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1186 close (fd);
1188 return crc == file_crc;
1193 INTERNAL_FUNCTION
1194 find_separate_debug_file
1196 SYNOPSIS
1197 char *find_separate_debug_file (bfd *abfd);
1199 DESCRIPTION
1200 Searches @var{abfd} for a reference to separate debugging
1201 information, scans various locations in the filesystem, including
1202 the file tree rooted at @var{debug_file_directory}, and returns a
1203 filename of such debugging information if the file is found and has
1204 matching CRC32. Returns NULL if no reference to debugging file
1205 exists, or file cannot be found.
1208 static char *
1209 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1211 char *basename;
1212 char *dir;
1213 char *debugfile;
1214 unsigned long crc32;
1215 int i;
1217 BFD_ASSERT (abfd);
1218 if (debug_file_directory == NULL)
1219 debug_file_directory = ".";
1221 /* BFD may have been opened from a stream. */
1222 if (! abfd->filename)
1223 return NULL;
1225 basename = get_debug_link_info (abfd, & crc32);
1226 if (basename == NULL)
1227 return NULL;
1229 if (strlen (basename) < 1)
1231 free (basename);
1232 return NULL;
1235 dir = strdup (abfd->filename);
1236 if (dir == NULL)
1238 free (basename);
1239 return NULL;
1241 BFD_ASSERT (strlen (dir) != 0);
1243 /* Strip off filename part. */
1244 for (i = strlen (dir) - 1; i >= 0; i--)
1245 if (IS_DIR_SEPARATOR (dir[i]))
1246 break;
1248 dir[i + 1] = '\0';
1249 BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
1251 debugfile = malloc (strlen (debug_file_directory) + 1
1252 + strlen (dir)
1253 + strlen (".debug/")
1254 + strlen (basename)
1255 + 1);
1256 if (debugfile == NULL)
1258 free (basename);
1259 free (dir);
1260 return NULL;
1263 /* First try in the same directory as the original file: */
1264 strcpy (debugfile, dir);
1265 strcat (debugfile, basename);
1267 if (separate_debug_file_exists (debugfile, crc32))
1269 free (basename);
1270 free (dir);
1271 return debugfile;
1274 /* Then try in a subdirectory called .debug. */
1275 strcpy (debugfile, dir);
1276 strcat (debugfile, ".debug/");
1277 strcat (debugfile, basename);
1279 if (separate_debug_file_exists (debugfile, crc32))
1281 free (basename);
1282 free (dir);
1283 return debugfile;
1286 /* Then try in the global debugfile directory. */
1287 strcpy (debugfile, debug_file_directory);
1288 i = strlen (debug_file_directory) - 1;
1289 if (i > 0
1290 && debug_file_directory[i] != '/'
1291 && dir[0] != '/')
1292 strcat (debugfile, "/");
1293 strcat (debugfile, dir);
1294 strcat (debugfile, basename);
1296 if (separate_debug_file_exists (debugfile, crc32))
1298 free (basename);
1299 free (dir);
1300 return debugfile;
1303 free (debugfile);
1304 free (basename);
1305 free (dir);
1306 return NULL;
1311 FUNCTION
1312 bfd_follow_gnu_debuglink
1314 SYNOPSIS
1315 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1317 DESCRIPTION
1319 Takes a BFD and searches it for a .gnu_debuglink section. If this
1320 section is found, it examines the section for the name and checksum
1321 of a '.debug' file containing auxiliary debugging information. It
1322 then searches the filesystem for this .debug file in some standard
1323 locations, including the directory tree rooted at @var{dir}, and if
1324 found returns the full filename.
1326 If @var{dir} is NULL, it will search a default path configured into
1327 libbfd at build time. [XXX this feature is not currently
1328 implemented].
1330 RETURNS
1331 <<NULL>> on any errors or failure to locate the .debug file,
1332 otherwise a pointer to a heap-allocated string containing the
1333 filename. The caller is responsible for freeing this string.
1336 char *
1337 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1339 return find_separate_debug_file (abfd, dir);
1343 FUNCTION
1344 bfd_create_gnu_debuglink_section
1346 SYNOPSIS
1347 struct bfd_section *bfd_create_gnu_debuglink_section
1348 (bfd *abfd, const char *filename);
1350 DESCRIPTION
1352 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized
1353 to be big enough to contain a link to the specified @var{filename}.
1355 RETURNS
1356 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is
1357 returned and bfd_error is set.
1360 asection *
1361 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1363 asection *sect;
1364 bfd_size_type debuglink_size;
1365 flagword flags;
1367 if (abfd == NULL || filename == NULL)
1369 bfd_set_error (bfd_error_invalid_operation);
1370 return NULL;
1373 /* Strip off any path components in filename. */
1374 filename = lbasename (filename);
1376 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1377 if (sect)
1379 /* Section already exists. */
1380 bfd_set_error (bfd_error_invalid_operation);
1381 return NULL;
1384 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1385 sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1386 if (sect == NULL)
1387 return NULL;
1389 debuglink_size = strlen (filename) + 1;
1390 debuglink_size += 3;
1391 debuglink_size &= ~3;
1392 debuglink_size += 4;
1394 if (! bfd_set_section_size (abfd, sect, debuglink_size))
1395 /* XXX Should we delete the section from the bfd ? */
1396 return NULL;
1398 return sect;
1403 FUNCTION
1404 bfd_fill_in_gnu_debuglink_section
1406 SYNOPSIS
1407 bfd_boolean bfd_fill_in_gnu_debuglink_section
1408 (bfd *abfd, struct bfd_section *sect, const char *filename);
1410 DESCRIPTION
1412 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1413 and fills in the contents of the section to contain a link to the
1414 specified @var{filename}. The filename should be relative to the
1415 current directory.
1417 RETURNS
1418 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1419 and bfd_error is set.
1422 bfd_boolean
1423 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1424 struct bfd_section *sect,
1425 const char *filename)
1427 bfd_size_type debuglink_size;
1428 unsigned long crc32;
1429 char * contents;
1430 bfd_size_type crc_offset;
1431 FILE * handle;
1432 static unsigned char buffer[8 * 1024];
1433 size_t count;
1435 if (abfd == NULL || sect == NULL || filename == NULL)
1437 bfd_set_error (bfd_error_invalid_operation);
1438 return FALSE;
1441 /* Make sure that we can read the file.
1442 XXX - Should we attempt to locate the debug info file using the same
1443 algorithm as gdb ? At the moment, since we are creating the
1444 .gnu_debuglink section, we insist upon the user providing us with a
1445 correct-for-section-creation-time path, but this need not conform to
1446 the gdb location algorithm. */
1447 handle = real_fopen (filename, FOPEN_RB);
1448 if (handle == NULL)
1450 bfd_set_error (bfd_error_system_call);
1451 return FALSE;
1454 crc32 = 0;
1455 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1456 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1457 fclose (handle);
1459 /* Strip off any path components in filename,
1460 now that we no longer need them. */
1461 filename = lbasename (filename);
1463 debuglink_size = strlen (filename) + 1;
1464 debuglink_size += 3;
1465 debuglink_size &= ~3;
1466 debuglink_size += 4;
1468 contents = malloc (debuglink_size);
1469 if (contents == NULL)
1471 /* XXX Should we delete the section from the bfd ? */
1472 bfd_set_error (bfd_error_no_memory);
1473 return FALSE;
1476 strcpy (contents, filename);
1477 crc_offset = debuglink_size - 4;
1479 bfd_put_32 (abfd, crc32, contents + crc_offset);
1481 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1483 /* XXX Should we delete the section from the bfd ? */
1484 free (contents);
1485 return FALSE;
1488 return TRUE;