1 /* opncls.c -- open and close a BFD.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "libiberty.h"
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 /* Counters used to initialize the bfd identifier. */
41 static unsigned int bfd_id_counter
= 0;
42 static unsigned int bfd_reserved_id_counter
= 0;
46 .{* Set to N to open the next N BFDs using an alternate id space. *}
47 .extern unsigned int bfd_use_reserved_id;
49 unsigned int bfd_use_reserved_id
= 0;
51 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
52 if we do that we can't use fcntl. */
54 /* Return a new BFD. All BFD's are allocated through this routine. */
61 nbfd
= (bfd
*) bfd_zmalloc (sizeof (bfd
));
65 if (bfd_use_reserved_id
)
67 nbfd
->id
= --bfd_reserved_id_counter
;
68 --bfd_use_reserved_id
;
71 nbfd
->id
= bfd_id_counter
++;
73 nbfd
->memory
= objalloc_create ();
74 if (nbfd
->memory
== NULL
)
76 bfd_set_error (bfd_error_no_memory
);
81 nbfd
->arch_info
= &bfd_default_arch_struct
;
83 if (!bfd_hash_table_init_n (& nbfd
->section_htab
, bfd_section_hash_newfunc
,
84 sizeof (struct section_hash_entry
), 13))
93 static const struct bfd_iovec opncls_iovec
;
95 /* Allocate a new BFD as a member of archive OBFD. */
98 _bfd_new_bfd_contained_in (bfd
*obfd
)
102 nbfd
= _bfd_new_bfd ();
105 nbfd
->xvec
= obfd
->xvec
;
106 nbfd
->iovec
= obfd
->iovec
;
107 if (obfd
->iovec
== &opncls_iovec
)
108 nbfd
->iostream
= obfd
->iostream
;
109 nbfd
->my_archive
= obfd
;
110 nbfd
->direction
= read_direction
;
111 nbfd
->target_defaulted
= obfd
->target_defaulted
;
118 _bfd_delete_bfd (bfd
*abfd
)
122 bfd_hash_table_free (&abfd
->section_htab
);
123 objalloc_free ((struct objalloc
*) abfd
->memory
);
127 free ((char *) abfd
->filename
);
128 free (abfd
->arelt_data
);
132 /* Free objalloc memory. */
135 _bfd_free_cached_info (bfd
*abfd
)
139 bfd_hash_table_free (&abfd
->section_htab
);
140 objalloc_free ((struct objalloc
*) abfd
->memory
);
142 abfd
->sections
= NULL
;
143 abfd
->section_last
= NULL
;
144 abfd
->outsymbols
= NULL
;
145 abfd
->tdata
.any
= NULL
;
146 abfd
->usrdata
= NULL
;
155 Opening and closing BFDs
158 Functions for opening and closing
166 bfd *bfd_fopen (const char *filename, const char *target,
167 const char *mode, int fd);
170 Open the file @var{filename} with the target @var{target}.
171 Return a pointer to the created BFD. If @var{fd} is not -1,
172 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
173 is used. @var{mode} is passed directly to <<fopen>> or
176 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
179 The new BFD is marked as cacheable iff @var{fd} is -1.
181 If <<NULL>> is returned then an error has occured. Possible errors
182 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
183 <<system_call>> error.
185 On error, @var{fd} is always closed.
187 A copy of the @var{filename} argument is stored in the newly created
188 BFD. It can be accessed via the bfd_get_filename() macro.
192 bfd_fopen (const char *filename
, const char *target
, const char *mode
, int fd
)
195 const bfd_target
*target_vec
;
197 nbfd
= _bfd_new_bfd ();
205 target_vec
= bfd_find_target (target
, nbfd
);
206 if (target_vec
== NULL
)
210 _bfd_delete_bfd (nbfd
);
216 nbfd
->iostream
= fdopen (fd
, mode
);
219 nbfd
->iostream
= real_fopen (filename
, mode
);
220 if (nbfd
->iostream
== NULL
)
222 bfd_set_error (bfd_error_system_call
);
223 _bfd_delete_bfd (nbfd
);
227 /* OK, put everything where it belongs. */
229 /* PR 11983: Do not cache the original filename, but
230 rather make a copy - the original might go away. */
231 nbfd
->filename
= xstrdup (filename
);
233 /* Figure out whether the user is opening the file for reading,
234 writing, or both, by looking at the MODE argument. */
235 if ((mode
[0] == 'r' || mode
[0] == 'w' || mode
[0] == 'a')
237 nbfd
->direction
= both_direction
;
238 else if (mode
[0] == 'r')
239 nbfd
->direction
= read_direction
;
241 nbfd
->direction
= write_direction
;
243 if (! bfd_cache_init (nbfd
))
245 _bfd_delete_bfd (nbfd
);
248 nbfd
->opened_once
= TRUE
;
250 /* If we opened the file by name, mark it cacheable; we can close it
251 and reopen it later. However, if a file descriptor was provided,
252 then it may have been opened with special flags that make it
253 unsafe to close and reopen the file. */
255 (void) bfd_set_cacheable (nbfd
, TRUE
);
265 bfd *bfd_openr (const char *filename, const char *target);
268 Open the file @var{filename} (using <<fopen>>) with the target
269 @var{target}. Return a pointer to the created BFD.
271 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
274 If <<NULL>> is returned then an error has occured. Possible errors
275 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
276 <<system_call>> error.
278 A copy of the @var{filename} argument is stored in the newly created
279 BFD. It can be accessed via the bfd_get_filename() macro.
283 bfd_openr (const char *filename
, const char *target
)
285 return bfd_fopen (filename
, target
, FOPEN_RB
, -1);
288 /* Don't try to `optimize' this function:
290 o - We lock using stack space so that interrupting the locking
291 won't cause a storage leak.
292 o - We open the file stream last, since we don't want to have to
293 close it if anything goes wrong. Closing the stream means closing
294 the file descriptor too, even though we didn't open it. */
300 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
303 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
304 <<fopen>>. It opens a BFD on a file already described by the
307 When the file is later <<bfd_close>>d, the file descriptor will
308 be closed. If the caller desires that this file descriptor be
309 cached by BFD (opened as needed, closed as needed to free
310 descriptors for other opens), with the supplied @var{fd} used as
311 an initial file descriptor (but subject to closure at any time),
312 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
313 is to assume no caching; the file descriptor will remain open
314 until <<bfd_close>>, and will not be affected by BFD operations
317 Possible errors are <<bfd_error_no_memory>>,
318 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
320 On error, @var{fd} is closed.
322 A copy of the @var{filename} argument is stored in the newly created
323 BFD. It can be accessed via the bfd_get_filename() macro.
327 bfd_fdopenr (const char *filename
, const char *target
, int fd
)
330 #if defined(HAVE_FCNTL) && defined(F_GETFL)
334 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
335 mode
= FOPEN_RUB
; /* Assume full access. */
337 fdflags
= fcntl (fd
, F_GETFL
, NULL
);
344 bfd_set_error (bfd_error_system_call
);
348 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
349 switch (fdflags
& (O_ACCMODE
))
351 case O_RDONLY
: mode
= FOPEN_RB
; break;
352 case O_WRONLY
: mode
= FOPEN_RUB
; break;
353 case O_RDWR
: mode
= FOPEN_RUB
; break;
358 return bfd_fopen (filename
, target
, mode
, fd
);
366 bfd *bfd_openstreamr (const char * filename, const char * target, void * stream);
370 Open a BFD for read access on an existing stdio stream. When
371 the BFD is passed to <<bfd_close>>, the stream will be closed.
373 A copy of the @var{filename} argument is stored in the newly created
374 BFD. It can be accessed via the bfd_get_filename() macro.
378 bfd_openstreamr (const char *filename
, const char *target
, void *streamarg
)
380 FILE *stream
= (FILE *) streamarg
;
382 const bfd_target
*target_vec
;
384 nbfd
= _bfd_new_bfd ();
388 target_vec
= bfd_find_target (target
, nbfd
);
389 if (target_vec
== NULL
)
391 _bfd_delete_bfd (nbfd
);
395 nbfd
->iostream
= stream
;
396 /* PR 11983: Do not cache the original filename, but
397 rather make a copy - the original might go away. */
398 nbfd
->filename
= xstrdup (filename
);
399 nbfd
->direction
= read_direction
;
401 if (! bfd_cache_init (nbfd
))
403 _bfd_delete_bfd (nbfd
);
415 bfd *bfd_openr_iovec (const char *filename, const char *target,
416 void *(*open_func) (struct bfd *nbfd,
419 file_ptr (*pread_func) (struct bfd *nbfd,
424 int (*close_func) (struct bfd *nbfd,
426 int (*stat_func) (struct bfd *abfd,
432 Create and return a BFD backed by a read-only @var{stream}.
433 The @var{stream} is created using @var{open_func}, accessed using
434 @var{pread_func} and destroyed using @var{close_func}.
436 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
439 Calls @var{open_func} (which can call <<bfd_zalloc>> and
440 <<bfd_get_filename>>) to obtain the read-only stream backing
441 the BFD. @var{open_func} either succeeds returning the
442 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
443 (setting <<bfd_error>>).
445 Calls @var{pread_func} to request @var{nbytes} of data from
446 @var{stream} starting at @var{offset} (e.g., via a call to
447 <<bfd_read>>). @var{pread_func} either succeeds returning the
448 number of bytes read (which can be less than @var{nbytes} when
449 end-of-file), or fails returning -1 (setting <<bfd_error>>).
451 Calls @var{close_func} when the BFD is later closed using
452 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
453 fails returning -1 (setting <<bfd_error>>).
455 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
456 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
457 on success, or returns -1 on failure (setting <<bfd_error>>).
459 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
460 occurred. Possible errors are <<bfd_error_no_memory>>,
461 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
463 A copy of the @var{filename} argument is stored in the newly created
464 BFD. It can be accessed via the bfd_get_filename() macro.
470 file_ptr (*pread
) (struct bfd
*abfd
, void *stream
, void *buf
,
471 file_ptr nbytes
, file_ptr offset
);
472 int (*close
) (struct bfd
*abfd
, void *stream
);
473 int (*stat
) (struct bfd
*abfd
, void *stream
, struct stat
*sb
);
478 opncls_btell (struct bfd
*abfd
)
480 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
485 opncls_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
487 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
490 case SEEK_SET
: vec
->where
= offset
; break;
491 case SEEK_CUR
: vec
->where
+= offset
; break;
492 case SEEK_END
: return -1;
498 opncls_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
500 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
501 file_ptr nread
= (vec
->pread
) (abfd
, vec
->stream
, buf
, nbytes
, vec
->where
);
509 opncls_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
510 const void *where ATTRIBUTE_UNUSED
,
511 file_ptr nbytes ATTRIBUTE_UNUSED
)
517 opncls_bclose (struct bfd
*abfd
)
519 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
520 /* Since the VEC's memory is bound to the bfd deleting the bfd will
523 if (vec
->close
!= NULL
)
524 status
= (vec
->close
) (abfd
, vec
->stream
);
525 abfd
->iostream
= NULL
;
530 opncls_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
536 opncls_bstat (struct bfd
*abfd
, struct stat
*sb
)
538 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
540 memset (sb
, 0, sizeof (*sb
));
541 if (vec
->stat
== NULL
)
544 return (vec
->stat
) (abfd
, vec
->stream
, sb
);
548 opncls_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
549 void *addr ATTRIBUTE_UNUSED
,
550 bfd_size_type len ATTRIBUTE_UNUSED
,
551 int prot ATTRIBUTE_UNUSED
,
552 int flags ATTRIBUTE_UNUSED
,
553 file_ptr offset ATTRIBUTE_UNUSED
,
554 void **map_addr ATTRIBUTE_UNUSED
,
555 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
560 static const struct bfd_iovec opncls_iovec
= {
561 &opncls_bread
, &opncls_bwrite
, &opncls_btell
, &opncls_bseek
,
562 &opncls_bclose
, &opncls_bflush
, &opncls_bstat
, &opncls_bmmap
566 bfd_openr_iovec (const char *filename
, const char *target
,
567 void *(*open_p
) (struct bfd
*, void *),
569 file_ptr (*pread_p
) (struct bfd
*, void *, void *,
571 int (*close_p
) (struct bfd
*, void *),
572 int (*stat_p
) (struct bfd
*, void *, struct stat
*))
575 const bfd_target
*target_vec
;
579 nbfd
= _bfd_new_bfd ();
583 target_vec
= bfd_find_target (target
, nbfd
);
584 if (target_vec
== NULL
)
586 _bfd_delete_bfd (nbfd
);
590 /* PR 11983: Do not cache the original filename, but
591 rather make a copy - the original might go away. */
592 nbfd
->filename
= xstrdup (filename
);
593 nbfd
->direction
= read_direction
;
595 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
596 stream
= (*open_p
) (nbfd
, open_closure
);
599 _bfd_delete_bfd (nbfd
);
603 vec
= (struct opncls
*) bfd_zalloc (nbfd
, sizeof (struct opncls
));
604 vec
->stream
= stream
;
605 vec
->pread
= pread_p
;
606 vec
->close
= close_p
;
609 nbfd
->iovec
= &opncls_iovec
;
610 nbfd
->iostream
= vec
;
615 /* bfd_openw -- open for writing.
616 Returns a pointer to a freshly-allocated BFD on success, or NULL.
618 See comment by bfd_fdopenr before you try to modify this function. */
625 bfd *bfd_openw (const char *filename, const char *target);
628 Create a BFD, associated with file @var{filename}, using the
629 file format @var{target}, and return a pointer to it.
631 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
632 <<bfd_error_invalid_target>>.
634 A copy of the @var{filename} argument is stored in the newly created
635 BFD. It can be accessed via the bfd_get_filename() macro.
639 bfd_openw (const char *filename
, const char *target
)
642 const bfd_target
*target_vec
;
644 /* nbfd has to point to head of malloc'ed block so that bfd_close may
645 reclaim it correctly. */
646 nbfd
= _bfd_new_bfd ();
650 target_vec
= bfd_find_target (target
, nbfd
);
651 if (target_vec
== NULL
)
653 _bfd_delete_bfd (nbfd
);
657 /* PR 11983: Do not cache the original filename, but
658 rather make a copy - the original might go away. */
659 nbfd
->filename
= xstrdup (filename
);
660 nbfd
->direction
= write_direction
;
662 if (bfd_open_file (nbfd
) == NULL
)
664 /* File not writeable, etc. */
665 bfd_set_error (bfd_error_system_call
);
666 _bfd_delete_bfd (nbfd
);
674 _maybe_make_executable (bfd
* abfd
)
676 /* If the file was open for writing and is now executable,
678 if (abfd
->direction
== write_direction
679 && (abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
683 if (stat (abfd
->filename
, &buf
) == 0
684 /* Do not attempt to change non-regular files. This is
685 here especially for configure scripts and kernel builds
686 which run tests with "ld [...] -o /dev/null". */
687 && S_ISREG(buf
.st_mode
))
689 unsigned int mask
= umask (0);
692 chmod (abfd
->filename
,
694 & (buf
.st_mode
| ((S_IXUSR
| S_IXGRP
| S_IXOTH
) &~ mask
))));
705 bfd_boolean bfd_close (bfd *abfd);
709 Close a BFD. If the BFD was open for writing, then pending
710 operations are completed and the file written out and closed.
711 If the created file is executable, then <<chmod>> is called
714 All memory attached to the BFD is released.
716 The file descriptor associated with the BFD is closed (even
717 if it was passed in to BFD by <<bfd_fdopenr>>).
720 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
725 bfd_close (bfd
*abfd
)
729 if (bfd_write_p (abfd
))
731 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
735 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
738 ret
= abfd
->iovec
->bclose (abfd
) == 0;
741 _maybe_make_executable (abfd
);
743 _bfd_delete_bfd (abfd
);
753 bfd_boolean bfd_close_all_done (bfd *);
756 Close a BFD. Differs from <<bfd_close>> since it does not
757 complete any pending operations. This routine would be used
758 if the application had just used BFD for swapping and didn't
759 want to use any of the writing code.
761 If the created file is executable, then <<chmod>> is called
764 All memory attached to the BFD is released.
767 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
771 bfd_close_all_done (bfd
*abfd
)
775 ret
= bfd_cache_close (abfd
);
778 _maybe_make_executable (abfd
);
780 _bfd_delete_bfd (abfd
);
790 bfd *bfd_create (const char *filename, bfd *templ);
793 Create a new BFD in the manner of <<bfd_openw>>, but without
794 opening a file. The new BFD takes the target from the target
795 used by @var{templ}. The format is always set to <<bfd_object>>.
797 A copy of the @var{filename} argument is stored in the newly created
798 BFD. It can be accessed via the bfd_get_filename() macro.
802 bfd_create (const char *filename
, bfd
*templ
)
806 nbfd
= _bfd_new_bfd ();
809 /* PR 11983: Do not cache the original filename, but
810 rather make a copy - the original might go away. */
811 nbfd
->filename
= xstrdup (filename
);
813 nbfd
->xvec
= templ
->xvec
;
814 nbfd
->direction
= no_direction
;
815 bfd_set_format (nbfd
, bfd_object
);
825 bfd_boolean bfd_make_writable (bfd *abfd);
828 Takes a BFD as created by <<bfd_create>> and converts it
829 into one like as returned by <<bfd_openw>>. It does this
830 by converting the BFD to BFD_IN_MEMORY. It's assumed that
831 you will call <<bfd_make_readable>> on this bfd later.
834 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
838 bfd_make_writable (bfd
*abfd
)
840 struct bfd_in_memory
*bim
;
842 if (abfd
->direction
!= no_direction
)
844 bfd_set_error (bfd_error_invalid_operation
);
848 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
850 return FALSE
; /* bfd_error already set. */
851 abfd
->iostream
= bim
;
852 /* bfd_bwrite will grow these as needed. */
856 abfd
->flags
|= BFD_IN_MEMORY
;
857 abfd
->iovec
= &_bfd_memory_iovec
;
859 abfd
->direction
= write_direction
;
870 bfd_boolean bfd_make_readable (bfd *abfd);
873 Takes a BFD as created by <<bfd_create>> and
874 <<bfd_make_writable>> and converts it into one like as
875 returned by <<bfd_openr>>. It does this by writing the
876 contents out to the memory buffer, then reversing the
880 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
883 bfd_make_readable (bfd
*abfd
)
885 if (abfd
->direction
!= write_direction
|| !(abfd
->flags
& BFD_IN_MEMORY
))
887 bfd_set_error (bfd_error_invalid_operation
);
891 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
894 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
897 abfd
->arch_info
= &bfd_default_arch_struct
;
900 abfd
->format
= bfd_unknown
;
901 abfd
->my_archive
= NULL
;
903 abfd
->opened_once
= FALSE
;
904 abfd
->output_has_begun
= FALSE
;
905 abfd
->section_count
= 0;
906 abfd
->usrdata
= NULL
;
907 abfd
->cacheable
= FALSE
;
908 abfd
->flags
|= BFD_IN_MEMORY
;
909 abfd
->mtime_set
= FALSE
;
911 abfd
->target_defaulted
= TRUE
;
912 abfd
->direction
= read_direction
;
915 abfd
->outsymbols
= 0;
918 bfd_section_list_clear (abfd
);
919 bfd_check_format (abfd
, bfd_object
);
929 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
932 Allocate a block of @var{wanted} bytes of memory attached to
933 <<abfd>> and return a pointer to it.
937 bfd_alloc (bfd
*abfd
, bfd_size_type size
)
940 unsigned long ul_size
= (unsigned long) size
;
943 /* A small negative size can result in objalloc_alloc allocating just
944 1 byte of memory, but the caller will be expecting more. So catch
946 || (size
!= 0 && (((ul_size
+ OBJALLOC_ALIGN
- 1) &~ (OBJALLOC_ALIGN
- 1)) == 0)))
948 bfd_set_error (bfd_error_no_memory
);
952 ret
= objalloc_alloc ((struct objalloc
*) abfd
->memory
, ul_size
);
954 bfd_set_error (bfd_error_no_memory
);
963 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
966 Allocate a block of @var{nmemb} elements of @var{size} bytes each
967 of memory attached to <<abfd>> and return a pointer to it.
971 bfd_alloc2 (bfd
*abfd
, bfd_size_type nmemb
, bfd_size_type size
)
973 if ((nmemb
| size
) >= HALF_BFD_SIZE_TYPE
975 && nmemb
> ~(bfd_size_type
) 0 / size
)
977 bfd_set_error (bfd_error_no_memory
);
981 return bfd_alloc (abfd
, size
* nmemb
);
989 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
992 Allocate a block of @var{wanted} bytes of zeroed memory
993 attached to <<abfd>> and return a pointer to it.
997 bfd_zalloc (bfd
*abfd
, bfd_size_type size
)
1001 res
= bfd_alloc (abfd
, size
);
1003 memset (res
, 0, (size_t) size
);
1012 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
1015 Allocate a block of @var{nmemb} elements of @var{size} bytes each
1016 of zeroed memory attached to <<abfd>> and return a pointer to it.
1020 bfd_zalloc2 (bfd
*abfd
, bfd_size_type nmemb
, bfd_size_type size
)
1024 if ((nmemb
| size
) >= HALF_BFD_SIZE_TYPE
1026 && nmemb
> ~(bfd_size_type
) 0 / size
)
1028 bfd_set_error (bfd_error_no_memory
);
1034 res
= bfd_alloc (abfd
, size
);
1036 memset (res
, 0, (size_t) size
);
1040 /* Free a block allocated for a BFD.
1041 Note: Also frees all more recently allocated blocks! */
1044 bfd_release (bfd
*abfd
, void *block
)
1046 objalloc_free_block ((struct objalloc
*) abfd
->memory
, block
);
1051 GNU Extension: separate debug-info files
1053 The idea here is that a special section called .gnu_debuglink might be
1054 embedded in a binary file, which indicates that some *other* file
1055 contains the real debugging information. This special section contains a
1056 filename and CRC32 checksum, which we read and resolve to another file,
1059 This facilitates "optional" provision of debugging information, without
1060 having to provide two complete copies of every binary object (with and
1061 without debug symbols). */
1063 #define GNU_DEBUGLINK ".gnu_debuglink"
1064 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1068 bfd_calc_gnu_debuglink_crc32
1071 unsigned long bfd_calc_gnu_debuglink_crc32
1072 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1075 Computes a CRC value as used in the .gnu_debuglink section.
1076 Advances the previously computed @var{crc} value by computing
1077 and adding in the crc32 for @var{len} bytes of @var{buf}.
1080 Return the updated CRC32 value.
1084 bfd_calc_gnu_debuglink_crc32 (unsigned long crc
,
1085 const unsigned char *buf
,
1088 static const unsigned long crc32_table
[256] =
1090 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1091 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1092 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1093 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1094 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1095 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1096 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1097 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1098 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1099 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1100 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1101 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1102 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1103 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1104 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1105 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1106 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1107 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1108 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1109 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1110 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1111 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1112 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1113 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1114 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1115 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1116 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1117 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1118 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1119 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1120 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1121 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1122 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1123 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1124 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1125 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1126 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1127 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1128 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1129 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1130 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1131 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1132 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1133 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1134 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1135 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1136 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1137 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1138 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1139 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1140 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1143 const unsigned char *end
;
1145 crc
= ~crc
& 0xffffffff;
1146 for (end
= buf
+ len
; buf
< end
; ++ buf
)
1147 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
1148 return ~crc
& 0xffffffff;
1154 bfd_get_debug_link_info
1157 char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1160 Fetch the filename and CRC32 value for any separate debuginfo
1161 associated with @var{abfd}. Return NULL if no such info found,
1162 otherwise return filename and update @var{crc32_out}. The
1163 returned filename is allocated with @code{malloc}; freeing it
1164 is the responsibility of the caller.
1168 bfd_get_debug_link_info (bfd
*abfd
, unsigned long *crc32_out
)
1171 unsigned long crc32
;
1173 unsigned int crc_offset
;
1177 BFD_ASSERT (crc32_out
);
1179 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1184 if (!bfd_malloc_and_get_section (abfd
, sect
, &contents
))
1186 if (contents
!= NULL
)
1191 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1192 name
= (char *) contents
;
1193 /* PR 17597: avoid reading off the end of the buffer. */
1194 crc_offset
= strnlen (name
, bfd_get_section_size (sect
)) + 1;
1195 crc_offset
= (crc_offset
+ 3) & ~3;
1196 if (crc_offset
>= bfd_get_section_size (sect
))
1199 crc32
= bfd_get_32 (abfd
, contents
+ crc_offset
);
1207 bfd_get_alt_debug_link_info
1210 char *bfd_get_alt_debug_link_info (bfd * abfd,
1211 bfd_size_type *buildid_len,
1212 bfd_byte **buildid_out);
1215 Fetch the filename and BuildID value for any alternate debuginfo
1216 associated with @var{abfd}. Return NULL if no such info found,
1217 otherwise return filename and update @var{buildid_len} and
1218 @var{buildid_out}. The returned filename and build_id are
1219 allocated with @code{malloc}; freeing them is the
1220 responsibility of the caller.
1224 bfd_get_alt_debug_link_info (bfd
* abfd
, bfd_size_type
*buildid_len
,
1225 bfd_byte
**buildid_out
)
1229 unsigned int buildid_offset
;
1233 BFD_ASSERT (buildid_len
);
1234 BFD_ASSERT (buildid_out
);
1236 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGALTLINK
);
1241 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1243 if (contents
!= NULL
)
1248 /* BuildID value is stored after the filename. */
1249 name
= (char *) contents
;
1250 buildid_offset
= strnlen (name
, bfd_get_section_size (sect
)) + 1;
1251 if (buildid_offset
>= bfd_get_section_size (sect
))
1254 *buildid_len
= bfd_get_section_size (sect
) - buildid_offset
;
1255 *buildid_out
= bfd_malloc (*buildid_len
);
1256 memcpy (*buildid_out
, contents
+ buildid_offset
, *buildid_len
);
1263 separate_debug_file_exists
1266 bfd_boolean separate_debug_file_exists
1267 (char *name, unsigned long crc32);
1270 Checks to see if @var{name} is a file and if its contents
1275 separate_debug_file_exists (const char *name
, const unsigned long crc
)
1277 static unsigned char buffer
[8 * 1024];
1278 unsigned long file_crc
= 0;
1280 bfd_size_type count
;
1284 f
= real_fopen (name
, FOPEN_RB
);
1288 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
1289 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1293 return crc
== file_crc
;
1298 separate_alt_debug_file_exists
1301 bfd_boolean separate_alt_debug_file_exists
1302 (char *name, unsigned long crc32);
1305 Checks to see if @var{name} is a file and if its BuildID
1306 matches @var{buildid}.
1310 separate_alt_debug_file_exists (const char *name
,
1311 const unsigned long buildid ATTRIBUTE_UNUSED
)
1317 f
= real_fopen (name
, FOPEN_RB
);
1321 /* FIXME: Add code to check buildid. */
1330 find_separate_debug_file
1333 char *find_separate_debug_file (bfd *abfd);
1336 Searches @var{abfd} for a section called @var{section_name} which
1337 is expected to contain a reference to a file containing separate
1338 debugging information. The function scans various locations in
1339 the filesystem, including the file tree rooted at
1340 @var{debug_file_directory}, and returns the first matching
1341 filename that it finds. If @var{check_crc} is TRUE then the
1342 contents of the file must also match the CRC value contained in
1343 @var{section_name}. Returns NULL if no valid file could be found.
1346 typedef char * (* get_func_type
) (bfd
*, unsigned long *);
1347 typedef bfd_boolean (* check_func_type
) (const char *, const unsigned long);
1350 find_separate_debug_file (bfd
* abfd
,
1351 const char * debug_file_directory
,
1352 get_func_type get_func
,
1353 check_func_type check_func
)
1359 unsigned long crc32
;
1361 size_t canon_dirlen
;
1364 if (debug_file_directory
== NULL
)
1365 debug_file_directory
= ".";
1367 /* BFD may have been opened from a stream. */
1368 if (abfd
->filename
== NULL
)
1370 bfd_set_error (bfd_error_invalid_operation
);
1374 base
= get_func (abfd
, & crc32
);
1379 if (base
[0] == '\0')
1382 bfd_set_error (bfd_error_no_debug_section
);
1386 for (dirlen
= strlen (abfd
->filename
); dirlen
> 0; dirlen
--)
1387 if (IS_DIR_SEPARATOR (abfd
->filename
[dirlen
- 1]))
1390 dir
= (char *) bfd_malloc (dirlen
+ 1);
1396 memcpy (dir
, abfd
->filename
, dirlen
);
1399 /* Compute the canonical name of the bfd object with all symbolic links
1400 resolved, for use in the global debugfile directory. */
1401 canon_dir
= lrealpath (abfd
->filename
);
1402 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
1403 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
1405 canon_dir
[canon_dirlen
] = '\0';
1407 debugfile
= (char *)
1408 bfd_malloc (strlen (debug_file_directory
) + 1
1409 + (canon_dirlen
> dirlen
? canon_dirlen
: dirlen
)
1410 + strlen (".debug/")
1413 if (debugfile
== NULL
)
1414 goto found
; /* Actually this returns NULL. */
1416 /* First try in the same directory as the original file: */
1417 strcpy (debugfile
, dir
);
1418 strcat (debugfile
, base
);
1420 if (check_func (debugfile
, crc32
))
1423 /* Then try in a subdirectory called .debug. */
1424 strcpy (debugfile
, dir
);
1425 strcat (debugfile
, ".debug/");
1426 strcat (debugfile
, base
);
1428 if (check_func (debugfile
, crc32
))
1431 /* Then try in the global debugfile directory. */
1432 strcpy (debugfile
, debug_file_directory
);
1433 dirlen
= strlen (debug_file_directory
) - 1;
1435 && debug_file_directory
[dirlen
] != '/'
1436 && canon_dir
[0] != '/')
1437 strcat (debugfile
, "/");
1438 strcat (debugfile
, canon_dir
);
1439 strcat (debugfile
, base
);
1441 if (check_func (debugfile
, crc32
))
1444 /* Failed to find the file. */
1458 bfd_follow_gnu_debuglink
1461 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1465 Takes a BFD and searches it for a .gnu_debuglink section. If this
1466 section is found, it examines the section for the name and checksum
1467 of a '.debug' file containing auxiliary debugging information. It
1468 then searches the filesystem for this .debug file in some standard
1469 locations, including the directory tree rooted at @var{dir}, and if
1470 found returns the full filename.
1472 If @var{dir} is NULL, it will search a default path configured into
1473 libbfd at build time. [XXX this feature is not currently
1477 <<NULL>> on any errors or failure to locate the .debug file,
1478 otherwise a pointer to a heap-allocated string containing the
1479 filename. The caller is responsible for freeing this string.
1483 bfd_follow_gnu_debuglink (bfd
*abfd
, const char *dir
)
1485 return find_separate_debug_file (abfd
, dir
,
1486 bfd_get_debug_link_info
,
1487 separate_debug_file_exists
);
1490 /* Helper for bfd_follow_gnu_debugaltlink. It just pretends to return
1491 a CRC. .gnu_debugaltlink supplies a build-id, which is different,
1492 but this is ok because separate_alt_debug_file_exists ignores the
1496 get_alt_debug_link_info_shim (bfd
* abfd
, unsigned long *crc32_out
)
1499 bfd_byte
*buildid
= NULL
;
1500 char *result
= bfd_get_alt_debug_link_info (abfd
, &len
, &buildid
);
1510 bfd_follow_gnu_debugaltlink
1513 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1517 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1518 section is found, it examines the section for the name of a file
1519 containing auxiliary debugging information. It then searches the
1520 filesystem for this file in a set of standard locations, including
1521 the directory tree rooted at @var{dir}, and if found returns the
1524 If @var{dir} is NULL, it will search a default path configured into
1525 libbfd at build time. [FIXME: This feature is not currently
1529 <<NULL>> on any errors or failure to locate the debug file,
1530 otherwise a pointer to a heap-allocated string containing the
1531 filename. The caller is responsible for freeing this string.
1535 bfd_follow_gnu_debugaltlink (bfd
*abfd
, const char *dir
)
1537 return find_separate_debug_file (abfd
, dir
,
1538 get_alt_debug_link_info_shim
,
1539 separate_alt_debug_file_exists
);
1544 bfd_create_gnu_debuglink_section
1547 struct bfd_section *bfd_create_gnu_debuglink_section
1548 (bfd *abfd, const char *filename);
1552 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized
1553 to be big enough to contain a link to the specified @var{filename}.
1556 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is
1557 returned and bfd_error is set.
1561 bfd_create_gnu_debuglink_section (bfd
*abfd
, const char *filename
)
1564 bfd_size_type debuglink_size
;
1567 if (abfd
== NULL
|| filename
== NULL
)
1569 bfd_set_error (bfd_error_invalid_operation
);
1573 /* Strip off any path components in filename. */
1574 filename
= lbasename (filename
);
1576 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1579 /* Section already exists. */
1580 bfd_set_error (bfd_error_invalid_operation
);
1584 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DEBUGGING
;
1585 sect
= bfd_make_section_with_flags (abfd
, GNU_DEBUGLINK
, flags
);
1589 debuglink_size
= strlen (filename
) + 1;
1590 debuglink_size
+= 3;
1591 debuglink_size
&= ~3;
1592 debuglink_size
+= 4;
1594 if (! bfd_set_section_size (abfd
, sect
, debuglink_size
))
1595 /* XXX Should we delete the section from the bfd ? */
1604 bfd_fill_in_gnu_debuglink_section
1607 bfd_boolean bfd_fill_in_gnu_debuglink_section
1608 (bfd *abfd, struct bfd_section *sect, const char *filename);
1612 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1613 and fills in the contents of the section to contain a link to the
1614 specified @var{filename}. The filename should be relative to the
1618 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1619 and bfd_error is set.
1623 bfd_fill_in_gnu_debuglink_section (bfd
*abfd
,
1624 struct bfd_section
*sect
,
1625 const char *filename
)
1627 bfd_size_type debuglink_size
;
1628 unsigned long crc32
;
1630 bfd_size_type crc_offset
;
1632 static unsigned char buffer
[8 * 1024];
1636 if (abfd
== NULL
|| sect
== NULL
|| filename
== NULL
)
1638 bfd_set_error (bfd_error_invalid_operation
);
1642 /* Make sure that we can read the file.
1643 XXX - Should we attempt to locate the debug info file using the same
1644 algorithm as gdb ? At the moment, since we are creating the
1645 .gnu_debuglink section, we insist upon the user providing us with a
1646 correct-for-section-creation-time path, but this need not conform to
1647 the gdb location algorithm. */
1648 handle
= real_fopen (filename
, FOPEN_RB
);
1651 bfd_set_error (bfd_error_system_call
);
1656 while ((count
= fread (buffer
, 1, sizeof buffer
, handle
)) > 0)
1657 crc32
= bfd_calc_gnu_debuglink_crc32 (crc32
, buffer
, count
);
1660 /* Strip off any path components in filename,
1661 now that we no longer need them. */
1662 filename
= lbasename (filename
);
1664 filelen
= strlen (filename
);
1665 debuglink_size
= filelen
+ 1;
1666 debuglink_size
+= 3;
1667 debuglink_size
&= ~3;
1668 debuglink_size
+= 4;
1670 contents
= (char *) bfd_malloc (debuglink_size
);
1671 if (contents
== NULL
)
1673 /* XXX Should we delete the section from the bfd ? */
1677 crc_offset
= debuglink_size
- 4;
1678 memcpy (contents
, filename
, filelen
);
1679 memset (contents
+ filelen
, 0, crc_offset
- filelen
);
1681 bfd_put_32 (abfd
, crc32
, contents
+ crc_offset
);
1683 if (! bfd_set_section_contents (abfd
, sect
, contents
, 0, debuglink_size
))
1685 /* XXX Should we delete the section from the bfd ? */