1 /* opncls.c -- open and close a BFD.
2 Copyright (C) 1990-2023 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"
31 #define S_IXUSR 0100 /* Execute by owner. */
34 #define S_IXGRP 0010 /* Execute by group. */
37 #define S_IXOTH 0001 /* Execute by others. */
40 /* Counters used to initialize the bfd identifier. */
42 static unsigned int bfd_id_counter
= 0;
43 static unsigned int bfd_reserved_id_counter
= 0;
47 .{* Set to N to open the next N BFDs using an alternate id space. *}
48 .extern unsigned int bfd_use_reserved_id;
50 unsigned int bfd_use_reserved_id
= 0;
52 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
53 if we do that we can't use fcntl. */
55 /* Return a new BFD. All BFD's are allocated through this routine. */
62 nbfd
= (bfd
*) bfd_zmalloc (sizeof (bfd
));
66 if (bfd_use_reserved_id
)
68 nbfd
->id
= --bfd_reserved_id_counter
;
69 --bfd_use_reserved_id
;
72 nbfd
->id
= bfd_id_counter
++;
74 nbfd
->memory
= objalloc_create ();
75 if (nbfd
->memory
== NULL
)
77 bfd_set_error (bfd_error_no_memory
);
82 nbfd
->arch_info
= &bfd_default_arch_struct
;
84 if (!bfd_hash_table_init_n (& nbfd
->section_htab
, bfd_section_hash_newfunc
,
85 sizeof (struct section_hash_entry
), 13))
87 objalloc_free ((struct objalloc
*) nbfd
->memory
);
92 nbfd
->archive_plugin_fd
= -1;
97 static const struct bfd_iovec opncls_iovec
;
99 /* Allocate a new BFD as a member of archive OBFD. */
102 _bfd_new_bfd_contained_in (bfd
*obfd
)
106 nbfd
= _bfd_new_bfd ();
109 nbfd
->xvec
= obfd
->xvec
;
110 nbfd
->iovec
= obfd
->iovec
;
111 if (obfd
->iovec
== &opncls_iovec
)
112 nbfd
->iostream
= obfd
->iostream
;
113 nbfd
->my_archive
= obfd
;
114 nbfd
->direction
= read_direction
;
115 nbfd
->target_defaulted
= obfd
->target_defaulted
;
116 nbfd
->lto_output
= obfd
->lto_output
;
117 nbfd
->no_export
= obfd
->no_export
;
124 _bfd_delete_bfd (bfd
*abfd
)
128 bfd_hash_table_free (&abfd
->section_htab
);
129 objalloc_free ((struct objalloc
*) abfd
->memory
);
132 free ((char *) bfd_get_filename (abfd
));
134 free (abfd
->arelt_data
);
138 /* Free objalloc memory. */
141 _bfd_free_cached_info (bfd
*abfd
)
145 const char *filename
= bfd_get_filename (abfd
);
148 /* We can't afford to lose the bfd filename when freeing
149 abfd->memory, because that would kill the cache.c scheme
150 of closing and reopening files in order to limit the
151 number of open files. To reopen, you need the filename.
152 And indeed _bfd_compute_and_write_armap calls
153 _bfd_free_cached_info to free up space used by symbols
154 and by check_format_matches. Which we want to continue
155 doing to handle very large archives. Later the archive
156 elements are copied, which might require reopening files.
157 We also want to keep using objalloc memory for the
158 filename since that allows the name to be updated
159 without either leaking memory or implementing some sort
160 of reference counted string for copies of the filename. */
161 size_t len
= strlen (filename
) + 1;
162 char *copy
= bfd_malloc (len
);
165 memcpy (copy
, filename
, len
);
166 abfd
->filename
= copy
;
168 bfd_hash_table_free (&abfd
->section_htab
);
169 objalloc_free ((struct objalloc
*) abfd
->memory
);
171 abfd
->sections
= NULL
;
172 abfd
->section_last
= NULL
;
173 abfd
->outsymbols
= NULL
;
174 abfd
->tdata
.any
= NULL
;
175 abfd
->usrdata
= NULL
;
184 Opening and closing BFDs
187 Functions for opening and closing
195 bfd *bfd_fopen (const char *filename, const char *target,
196 const char *mode, int fd);
199 Open the file @var{filename} with the target @var{target}.
200 Return a pointer to the created BFD. If @var{fd} is not -1,
201 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
202 is used. @var{mode} is passed directly to <<fopen>> or
205 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
208 The new BFD is marked as cacheable iff @var{fd} is -1.
210 If <<NULL>> is returned then an error has occured. Possible errors
211 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
212 <<system_call>> error.
214 On error, @var{fd} is always closed.
216 A copy of the @var{filename} argument is stored in the newly created
217 BFD. It can be accessed via the bfd_get_filename() macro.
221 bfd_fopen (const char *filename
, const char *target
, const char *mode
, int fd
)
224 const bfd_target
*target_vec
;
226 nbfd
= _bfd_new_bfd ();
234 target_vec
= bfd_find_target (target
, nbfd
);
235 if (target_vec
== NULL
)
239 _bfd_delete_bfd (nbfd
);
245 nbfd
->iostream
= fdopen (fd
, mode
);
248 nbfd
->iostream
= _bfd_real_fopen (filename
, mode
);
249 if (nbfd
->iostream
== NULL
)
251 bfd_set_error (bfd_error_system_call
);
254 _bfd_delete_bfd (nbfd
);
258 /* OK, put everything where it belongs. */
260 /* PR 11983: Do not cache the original filename, but
261 rather make a copy - the original might go away. */
262 if (!bfd_set_filename (nbfd
, filename
))
264 fclose (nbfd
->iostream
);
265 _bfd_delete_bfd (nbfd
);
269 /* Figure out whether the user is opening the file for reading,
270 writing, or both, by looking at the MODE argument. */
271 if ((mode
[0] == 'r' || mode
[0] == 'w' || mode
[0] == 'a')
273 nbfd
->direction
= both_direction
;
274 else if (mode
[0] == 'r')
275 nbfd
->direction
= read_direction
;
277 nbfd
->direction
= write_direction
;
279 if (!bfd_cache_init (nbfd
))
281 fclose (nbfd
->iostream
);
282 _bfd_delete_bfd (nbfd
);
285 nbfd
->opened_once
= true;
287 /* If we opened the file by name, mark it cacheable; we can close it
288 and reopen it later. However, if a file descriptor was provided,
289 then it may have been opened with special flags that make it
290 unsafe to close and reopen the file. */
292 (void) bfd_set_cacheable (nbfd
, true);
302 bfd *bfd_openr (const char *filename, const char *target);
305 Open the file @var{filename} (using <<fopen>>) with the target
306 @var{target}. Return a pointer to the created BFD.
308 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
311 If <<NULL>> is returned then an error has occured. Possible errors
312 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
313 <<system_call>> error.
315 A copy of the @var{filename} argument is stored in the newly created
316 BFD. It can be accessed via the bfd_get_filename() macro.
320 bfd_openr (const char *filename
, const char *target
)
322 return bfd_fopen (filename
, target
, FOPEN_RB
, -1);
325 /* Don't try to `optimize' this function:
327 o - We lock using stack space so that interrupting the locking
328 won't cause a storage leak.
329 o - We open the file stream last, since we don't want to have to
330 close it if anything goes wrong. Closing the stream means closing
331 the file descriptor too, even though we didn't open it. */
337 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
340 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
341 <<fopen>>. It opens a BFD on a file already described by the
344 When the file is later <<bfd_close>>d, the file descriptor will
345 be closed. If the caller desires that this file descriptor be
346 cached by BFD (opened as needed, closed as needed to free
347 descriptors for other opens), with the supplied @var{fd} used as
348 an initial file descriptor (but subject to closure at any time),
349 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
350 is to assume no caching; the file descriptor will remain open
351 until <<bfd_close>>, and will not be affected by BFD operations
354 Possible errors are <<bfd_error_no_memory>>,
355 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
357 On error, @var{fd} is closed.
359 A copy of the @var{filename} argument is stored in the newly created
360 BFD. It can be accessed via the bfd_get_filename() macro.
364 bfd_fdopenr (const char *filename
, const char *target
, int fd
)
367 #if defined(HAVE_FCNTL) && defined(F_GETFL)
371 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
372 mode
= FOPEN_RUB
; /* Assume full access. */
374 fdflags
= fcntl (fd
, F_GETFL
, NULL
);
381 bfd_set_error (bfd_error_system_call
);
385 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
386 switch (fdflags
& (O_ACCMODE
))
388 case O_RDONLY
: mode
= FOPEN_RB
; break;
389 case O_WRONLY
: mode
= FOPEN_RUB
; break;
390 case O_RDWR
: mode
= FOPEN_RUB
; break;
395 return bfd_fopen (filename
, target
, mode
, fd
);
403 bfd *bfd_fdopenw (const char *filename, const char *target, int fd);
406 <<bfd_fdopenw>> is exactly like <<bfd_fdopenr>> with the exception that
407 the resulting BFD is suitable for output.
411 bfd_fdopenw (const char *filename
, const char *target
, int fd
)
413 bfd
*out
= bfd_fdopenr (filename
, target
, fd
);
417 if (!bfd_write_p (out
))
420 _bfd_delete_bfd (out
);
422 bfd_set_error (bfd_error_invalid_operation
);
425 out
->direction
= write_direction
;
436 bfd *bfd_openstreamr (const char * filename, const char * target,
440 Open a BFD for read access on an existing stdio stream. When
441 the BFD is passed to <<bfd_close>>, the stream will be closed.
443 A copy of the @var{filename} argument is stored in the newly created
444 BFD. It can be accessed via the bfd_get_filename() macro.
448 bfd_openstreamr (const char *filename
, const char *target
, void *streamarg
)
450 FILE *stream
= (FILE *) streamarg
;
452 const bfd_target
*target_vec
;
454 nbfd
= _bfd_new_bfd ();
458 target_vec
= bfd_find_target (target
, nbfd
);
459 if (target_vec
== NULL
)
461 _bfd_delete_bfd (nbfd
);
465 nbfd
->iostream
= stream
;
466 /* PR 11983: Do not cache the original filename, but
467 rather make a copy - the original might go away. */
468 if (!bfd_set_filename (nbfd
, filename
))
470 _bfd_delete_bfd (nbfd
);
473 nbfd
->direction
= read_direction
;
475 if (! bfd_cache_init (nbfd
))
477 _bfd_delete_bfd (nbfd
);
489 bfd *bfd_openr_iovec (const char *filename, const char *target,
490 void *(*open_func) (struct bfd *nbfd,
493 file_ptr (*pread_func) (struct bfd *nbfd,
498 int (*close_func) (struct bfd *nbfd,
500 int (*stat_func) (struct bfd *abfd,
505 Create and return a BFD backed by a read-only @var{stream}.
506 The @var{stream} is created using @var{open_func}, accessed using
507 @var{pread_func} and destroyed using @var{close_func}.
509 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
512 Calls @var{open_func} (which can call <<bfd_zalloc>> and
513 <<bfd_get_filename>>) to obtain the read-only stream backing
514 the BFD. @var{open_func} either succeeds returning the
515 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
516 (setting <<bfd_error>>).
518 Calls @var{pread_func} to request @var{nbytes} of data from
519 @var{stream} starting at @var{offset} (e.g., via a call to
520 <<bfd_read>>). @var{pread_func} either succeeds returning the
521 number of bytes read (which can be less than @var{nbytes} when
522 end-of-file), or fails returning -1 (setting <<bfd_error>>).
524 Calls @var{close_func} when the BFD is later closed using
525 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
526 fails returning -1 (setting <<bfd_error>>).
528 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
529 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
530 on success, or returns -1 on failure (setting <<bfd_error>>).
532 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
533 occurred. Possible errors are <<bfd_error_no_memory>>,
534 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
536 A copy of the @var{filename} argument is stored in the newly created
537 BFD. It can be accessed via the bfd_get_filename() macro.
543 file_ptr (*pread
) (struct bfd
*abfd
, void *stream
, void *buf
,
544 file_ptr nbytes
, file_ptr offset
);
545 int (*close
) (struct bfd
*abfd
, void *stream
);
546 int (*stat
) (struct bfd
*abfd
, void *stream
, struct stat
*sb
);
551 opncls_btell (struct bfd
*abfd
)
553 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
558 opncls_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
560 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
563 case SEEK_SET
: vec
->where
= offset
; break;
564 case SEEK_CUR
: vec
->where
+= offset
; break;
565 case SEEK_END
: return -1;
571 opncls_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
573 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
574 file_ptr nread
= (vec
->pread
) (abfd
, vec
->stream
, buf
, nbytes
, vec
->where
);
583 opncls_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
584 const void *where ATTRIBUTE_UNUSED
,
585 file_ptr nbytes ATTRIBUTE_UNUSED
)
591 opncls_bclose (struct bfd
*abfd
)
593 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
594 /* Since the VEC's memory is bound to the bfd deleting the bfd will
598 if (vec
->close
!= NULL
)
599 status
= (vec
->close
) (abfd
, vec
->stream
);
600 abfd
->iostream
= NULL
;
605 opncls_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
611 opncls_bstat (struct bfd
*abfd
, struct stat
*sb
)
613 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
615 memset (sb
, 0, sizeof (*sb
));
616 if (vec
->stat
== NULL
)
619 return (vec
->stat
) (abfd
, vec
->stream
, sb
);
623 opncls_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
624 void *addr ATTRIBUTE_UNUSED
,
625 bfd_size_type len ATTRIBUTE_UNUSED
,
626 int prot ATTRIBUTE_UNUSED
,
627 int flags ATTRIBUTE_UNUSED
,
628 file_ptr offset ATTRIBUTE_UNUSED
,
629 void **map_addr ATTRIBUTE_UNUSED
,
630 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
635 static const struct bfd_iovec opncls_iovec
=
637 &opncls_bread
, &opncls_bwrite
, &opncls_btell
, &opncls_bseek
,
638 &opncls_bclose
, &opncls_bflush
, &opncls_bstat
, &opncls_bmmap
642 bfd_openr_iovec (const char *filename
, const char *target
,
643 void *(*open_p
) (struct bfd
*, void *),
645 file_ptr (*pread_p
) (struct bfd
*, void *, void *,
647 int (*close_p
) (struct bfd
*, void *),
648 int (*stat_p
) (struct bfd
*, void *, struct stat
*))
651 const bfd_target
*target_vec
;
655 nbfd
= _bfd_new_bfd ();
659 target_vec
= bfd_find_target (target
, nbfd
);
660 if (target_vec
== NULL
)
662 _bfd_delete_bfd (nbfd
);
666 /* PR 11983: Do not cache the original filename, but
667 rather make a copy - the original might go away. */
668 if (!bfd_set_filename (nbfd
, filename
))
670 _bfd_delete_bfd (nbfd
);
673 nbfd
->direction
= read_direction
;
675 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
676 stream
= (*open_p
) (nbfd
, open_closure
);
679 _bfd_delete_bfd (nbfd
);
683 vec
= (struct opncls
*) bfd_zalloc (nbfd
, sizeof (struct opncls
));
684 vec
->stream
= stream
;
685 vec
->pread
= pread_p
;
686 vec
->close
= close_p
;
689 nbfd
->iovec
= &opncls_iovec
;
690 nbfd
->iostream
= vec
;
695 /* bfd_openw -- open for writing.
696 Returns a pointer to a freshly-allocated BFD on success, or NULL.
698 See comment by bfd_fdopenr before you try to modify this function. */
705 bfd *bfd_openw (const char *filename, const char *target);
708 Create a BFD, associated with file @var{filename}, using the
709 file format @var{target}, and return a pointer to it.
711 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
712 <<bfd_error_invalid_target>>.
714 A copy of the @var{filename} argument is stored in the newly created
715 BFD. It can be accessed via the bfd_get_filename() macro.
719 bfd_openw (const char *filename
, const char *target
)
722 const bfd_target
*target_vec
;
724 /* nbfd has to point to head of malloc'ed block so that bfd_close may
725 reclaim it correctly. */
726 nbfd
= _bfd_new_bfd ();
730 target_vec
= bfd_find_target (target
, nbfd
);
731 if (target_vec
== NULL
)
733 _bfd_delete_bfd (nbfd
);
737 /* PR 11983: Do not cache the original filename, but
738 rather make a copy - the original might go away. */
739 if (!bfd_set_filename (nbfd
, filename
))
741 _bfd_delete_bfd (nbfd
);
744 nbfd
->direction
= write_direction
;
746 if (bfd_open_file (nbfd
) == NULL
)
748 /* File not writeable, etc. */
749 bfd_set_error (bfd_error_system_call
);
750 _bfd_delete_bfd (nbfd
);
758 _maybe_make_executable (bfd
* abfd
)
760 /* If the file was open for writing and is now executable,
762 if (abfd
->direction
== write_direction
763 && (abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
767 if (stat (bfd_get_filename (abfd
), &buf
) == 0
768 /* Do not attempt to change non-regular files. This is
769 here especially for configure scripts and kernel builds
770 which run tests with "ld [...] -o /dev/null". */
771 && S_ISREG(buf
.st_mode
))
773 unsigned int mask
= umask (0);
776 chmod (bfd_get_filename (abfd
),
778 & (buf
.st_mode
| ((S_IXUSR
| S_IXGRP
| S_IXOTH
) &~ mask
))));
788 bool bfd_close (bfd *abfd);
791 Close a BFD. If the BFD was open for writing, then pending
792 operations are completed and the file written out and closed.
793 If the created file is executable, then <<chmod>> is called
796 All memory attached to the BFD is released.
798 The file descriptor associated with the BFD is closed (even
799 if it was passed in to BFD by <<bfd_fdopenr>>).
801 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
805 bfd_close (bfd
*abfd
)
807 bool ret
= (!bfd_write_p (abfd
)
808 || BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)));
810 return bfd_close_all_done (abfd
) && ret
;
818 bool bfd_close_all_done (bfd *);
821 Close a BFD. Differs from <<bfd_close>> since it does not
822 complete any pending operations. This routine would be used
823 if the application had just used BFD for swapping and didn't
824 want to use any of the writing code.
826 If the created file is executable, then <<chmod>> is called
829 All memory attached to the BFD is released.
831 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
835 bfd_close_all_done (bfd
*abfd
)
837 bool ret
= BFD_SEND (abfd
, _close_and_cleanup
, (abfd
));
839 if (ret
&& abfd
->iovec
!= NULL
)
841 ret
= abfd
->iovec
->bclose (abfd
) == 0;
844 _maybe_make_executable (abfd
);
847 _bfd_delete_bfd (abfd
);
857 bfd *bfd_create (const char *filename, bfd *templ);
860 Create a new BFD in the manner of <<bfd_openw>>, but without
861 opening a file. The new BFD takes the target from the target
862 used by @var{templ}. The format is always set to <<bfd_object>>.
864 A copy of the @var{filename} argument is stored in the newly created
865 BFD. It can be accessed via the bfd_get_filename() macro.
869 bfd_create (const char *filename
, bfd
*templ
)
873 nbfd
= _bfd_new_bfd ();
876 /* PR 11983: Do not cache the original filename, but
877 rather make a copy - the original might go away. */
878 if (!bfd_set_filename (nbfd
, filename
))
880 _bfd_delete_bfd (nbfd
);
884 nbfd
->xvec
= templ
->xvec
;
885 nbfd
->direction
= no_direction
;
886 bfd_set_format (nbfd
, bfd_object
);
896 bool bfd_make_writable (bfd *abfd);
899 Takes a BFD as created by <<bfd_create>> and converts it
900 into one like as returned by <<bfd_openw>>. It does this
901 by converting the BFD to BFD_IN_MEMORY. It's assumed that
902 you will call <<bfd_make_readable>> on this bfd later.
904 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
908 bfd_make_writable (bfd
*abfd
)
910 struct bfd_in_memory
*bim
;
912 if (abfd
->direction
!= no_direction
)
914 bfd_set_error (bfd_error_invalid_operation
);
918 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
920 return false; /* bfd_error already set. */
921 abfd
->iostream
= bim
;
922 /* bfd_bwrite will grow these as needed. */
926 abfd
->flags
|= BFD_IN_MEMORY
;
927 abfd
->iovec
= &_bfd_memory_iovec
;
929 abfd
->direction
= write_direction
;
940 bool bfd_make_readable (bfd *abfd);
943 Takes a BFD as created by <<bfd_create>> and
944 <<bfd_make_writable>> and converts it into one like as
945 returned by <<bfd_openr>>. It does this by writing the
946 contents out to the memory buffer, then reversing the
949 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
952 bfd_make_readable (bfd
*abfd
)
954 if (abfd
->direction
!= write_direction
|| !(abfd
->flags
& BFD_IN_MEMORY
))
956 bfd_set_error (bfd_error_invalid_operation
);
960 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
963 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
966 abfd
->arch_info
= &bfd_default_arch_struct
;
969 abfd
->format
= bfd_unknown
;
970 abfd
->my_archive
= NULL
;
972 abfd
->opened_once
= false;
973 abfd
->output_has_begun
= false;
974 abfd
->section_count
= 0;
975 abfd
->usrdata
= NULL
;
976 abfd
->cacheable
= false;
977 abfd
->flags
|= BFD_IN_MEMORY
;
978 abfd
->mtime_set
= false;
980 abfd
->target_defaulted
= true;
981 abfd
->direction
= read_direction
;
984 abfd
->outsymbols
= 0;
988 bfd_section_list_clear (abfd
);
989 bfd_check_format (abfd
, bfd_object
);
999 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
1002 Allocate a block of @var{wanted} bytes of memory attached to
1003 <<abfd>> and return a pointer to it.
1007 bfd_alloc (bfd
*abfd
, bfd_size_type size
)
1010 unsigned long ul_size
= (unsigned long) size
;
1013 /* Note - although objalloc_alloc takes an unsigned long as its
1014 argument, internally the size is treated as a signed long. This can
1015 lead to problems where, for example, a request to allocate -1 bytes
1016 can result in just 1 byte being allocated, rather than
1017 ((unsigned long) -1) bytes. Also memory checkers will often
1018 complain about attempts to allocate a negative amount of memory.
1019 So to stop these problems we fail if the size is negative. */
1020 || ((signed long) ul_size
) < 0)
1022 bfd_set_error (bfd_error_no_memory
);
1026 ret
= objalloc_alloc ((struct objalloc
*) abfd
->memory
, ul_size
);
1028 bfd_set_error (bfd_error_no_memory
);
1030 abfd
->alloc_size
+= size
;
1039 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
1042 Allocate a block of @var{wanted} bytes of zeroed memory
1043 attached to <<abfd>> and return a pointer to it.
1047 bfd_zalloc (bfd
*abfd
, bfd_size_type size
)
1051 res
= bfd_alloc (abfd
, size
);
1053 memset (res
, 0, (size_t) size
);
1057 /* Free a block allocated for a BFD.
1058 Note: Also frees all more recently allocated blocks! */
1061 bfd_release (bfd
*abfd
, void *block
)
1063 objalloc_free_block ((struct objalloc
*) abfd
->memory
, block
);
1068 GNU Extension: separate debug-info files
1070 The idea here is that a special section called .gnu_debuglink might be
1071 embedded in a binary file, which indicates that some *other* file
1072 contains the real debugging information. This special section contains a
1073 filename and CRC32 checksum, which we read and resolve to another file,
1076 This facilitates "optional" provision of debugging information, without
1077 having to provide two complete copies of every binary object (with and
1078 without debug symbols). */
1080 #define GNU_DEBUGLINK ".gnu_debuglink"
1081 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1085 bfd_calc_gnu_debuglink_crc32
1088 unsigned long bfd_calc_gnu_debuglink_crc32
1089 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1092 Computes a CRC value as used in the .gnu_debuglink section.
1093 Advances the previously computed @var{crc} value by computing
1094 and adding in the crc32 for @var{len} bytes of @var{buf}.
1096 Return the updated CRC32 value.
1100 bfd_calc_gnu_debuglink_crc32 (unsigned long crc
,
1101 const unsigned char *buf
,
1104 static const unsigned long crc32_table
[256] =
1106 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1107 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1108 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1109 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1110 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1111 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1112 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1113 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1114 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1115 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1116 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1117 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1118 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1119 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1120 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1121 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1122 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1123 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1124 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1125 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1126 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1127 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1128 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1129 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1130 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1131 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1132 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1133 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1134 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1135 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1136 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1137 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1138 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1139 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1140 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1141 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1142 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1143 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1144 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1145 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1146 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1147 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1148 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1149 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1150 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1151 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1152 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1153 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1154 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1155 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1156 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1159 const unsigned char *end
;
1161 crc
= ~crc
& 0xffffffff;
1162 for (end
= buf
+ len
; buf
< end
; ++ buf
)
1163 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
1164 return ~crc
& 0xffffffff;
1170 bfd_get_debug_link_info_1
1173 char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out);
1176 Extracts the filename and CRC32 value for any separate debug
1177 information file associated with @var{abfd}.
1179 The @var{crc32_out} parameter is an untyped pointer because
1180 this routine is used as a @code{get_func_type} function, but it
1181 is expected to be an unsigned long pointer.
1183 Returns the filename of the associated debug information file,
1184 or NULL if there is no such file. If the filename was found
1185 then the contents of @var{crc32_out} are updated to hold the
1186 corresponding CRC32 value for the file.
1188 The returned filename is allocated with @code{malloc}; freeing
1189 it is the responsibility of the caller.
1193 bfd_get_debug_link_info_1 (bfd
*abfd
, void *crc32_out
)
1196 unsigned long *crc32
= (unsigned long *) crc32_out
;
1198 unsigned int crc_offset
;
1201 ufile_ptr file_size
;
1204 BFD_ASSERT (crc32_out
);
1206 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1211 size
= bfd_section_size (sect
);
1212 file_size
= bfd_get_size (abfd
);
1214 /* PR 22794: Make sure that the section has a reasonable size. */
1215 if (size
< 8 || (file_size
!= 0 && size
>= file_size
))
1218 if (!bfd_malloc_and_get_section (abfd
, sect
, &contents
))
1224 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1225 name
= (char *) contents
;
1226 /* PR 17597: Avoid reading off the end of the buffer. */
1227 crc_offset
= strnlen (name
, size
) + 1;
1228 crc_offset
= (crc_offset
+ 3) & ~3;
1229 if (crc_offset
+ 4 > size
)
1232 *crc32
= bfd_get_32 (abfd
, contents
+ crc_offset
);
1239 bfd_get_debug_link_info
1242 char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1245 Extracts the filename and CRC32 value for any separate debug
1246 information file associated with @var{abfd}.
1248 Returns the filename of the associated debug information file,
1249 or NULL if there is no such file. If the filename was found
1250 then the contents of @var{crc32_out} are updated to hold the
1251 corresponding CRC32 value for the file.
1253 The returned filename is allocated with @code{malloc}; freeing
1254 it is the responsibility of the caller.
1258 bfd_get_debug_link_info (bfd
*abfd
, unsigned long *crc32_out
)
1260 return bfd_get_debug_link_info_1 (abfd
, crc32_out
);
1265 bfd_get_alt_debug_link_info
1268 char *bfd_get_alt_debug_link_info (bfd * abfd,
1269 bfd_size_type *buildid_len,
1270 bfd_byte **buildid_out);
1273 Fetch the filename and BuildID value for any alternate debuginfo
1274 associated with @var{abfd}. Return NULL if no such info found,
1275 otherwise return filename and update @var{buildid_len} and
1276 @var{buildid_out}. The returned filename and build_id are
1277 allocated with @code{malloc}; freeing them is the responsibility
1282 bfd_get_alt_debug_link_info (bfd
* abfd
, bfd_size_type
*buildid_len
,
1283 bfd_byte
**buildid_out
)
1287 unsigned int buildid_offset
;
1290 ufile_ptr file_size
;
1293 BFD_ASSERT (buildid_len
);
1294 BFD_ASSERT (buildid_out
);
1296 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGALTLINK
);
1301 size
= bfd_section_size (sect
);
1302 file_size
= bfd_get_size (abfd
);
1303 if (size
< 8 || (file_size
!= 0 && size
>= file_size
))
1306 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1312 /* BuildID value is stored after the filename. */
1313 name
= (char *) contents
;
1314 buildid_offset
= strnlen (name
, size
) + 1;
1315 if (buildid_offset
>= bfd_section_size (sect
))
1318 *buildid_len
= size
- buildid_offset
;
1319 *buildid_out
= bfd_malloc (*buildid_len
);
1320 memcpy (*buildid_out
, contents
+ buildid_offset
, *buildid_len
);
1327 separate_debug_file_exists
1330 bool separate_debug_file_exists
1331 (char *name, void *crc32_p);
1334 Checks to see if @var{name} is a file and if its contents
1335 match @var{crc32}, which is a pointer to an @code{unsigned
1336 long} containing a CRC32.
1338 The @var{crc32_p} parameter is an untyped pointer because
1339 this routine is used as a @code{check_func_type} function.
1343 separate_debug_file_exists (const char *name
, void *crc32_p
)
1345 unsigned char buffer
[8 * 1024];
1346 unsigned long file_crc
= 0;
1348 bfd_size_type count
;
1352 BFD_ASSERT (crc32_p
);
1354 crc
= *(unsigned long *) crc32_p
;
1356 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1360 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
1361 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1365 return crc
== file_crc
;
1370 separate_alt_debug_file_exists
1373 bool separate_alt_debug_file_exists
1374 (char *name, void *unused);
1377 Checks to see if @var{name} is a file.
1381 separate_alt_debug_file_exists (const char *name
, void *unused ATTRIBUTE_UNUSED
)
1387 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1398 find_separate_debug_file
1401 char *find_separate_debug_file
1402 (bfd *abfd, const char *dir, bool include_dirs,
1403 get_func_type get, check_func_type check, void *data);
1406 Searches for a debug information file corresponding to @var{abfd}.
1408 The name of the separate debug info file is returned by the
1409 @var{get} function. This function scans various fixed locations
1410 in the filesystem, including the file tree rooted at @var{dir}.
1411 If the @var{include_dirs} parameter is true then the directory
1412 components of @var{abfd}'s filename will be included in the
1415 @var{data} is passed unmodified to the @var{get} and @var{check}
1416 functions. It is generally used to implement build-id-like
1417 matching in the callback functions.
1419 Returns the filename of the first file to be found which
1420 receives a TRUE result from the @var{check} function.
1421 Returns NULL if no valid file could be found.
1424 typedef char * (*get_func_type
) (bfd
*, void *);
1425 typedef bool (*check_func_type
) (const char *, void *);
1428 find_separate_debug_file (bfd
*abfd
,
1429 const char *debug_file_directory
,
1431 get_func_type get_func
,
1432 check_func_type check_func
,
1440 size_t canon_dirlen
;
1443 if (debug_file_directory
== NULL
)
1444 debug_file_directory
= ".";
1446 /* BFD may have been opened from a stream. */
1447 if (bfd_get_filename (abfd
) == NULL
)
1449 bfd_set_error (bfd_error_invalid_operation
);
1453 base
= get_func (abfd
, func_data
);
1458 if (base
[0] == '\0')
1461 bfd_set_error (bfd_error_no_debug_section
);
1467 const char *fname
= bfd_get_filename (abfd
);
1468 for (dirlen
= strlen (fname
); dirlen
> 0; dirlen
--)
1469 if (IS_DIR_SEPARATOR (fname
[dirlen
- 1]))
1472 dir
= (char *) bfd_malloc (dirlen
+ 1);
1478 memcpy (dir
, fname
, dirlen
);
1483 dir
= (char *) bfd_malloc (1);
1488 /* Compute the canonical name of the bfd object with all symbolic links
1489 resolved, for use in the global debugfile directory. */
1490 canon_dir
= lrealpath (bfd_get_filename (abfd
));
1491 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
1492 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
1494 canon_dir
[canon_dirlen
] = '\0';
1496 #ifndef EXTRA_DEBUG_ROOT1
1497 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1499 #ifndef EXTRA_DEBUG_ROOT2
1500 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1503 debugfile
= (char *)
1504 bfd_malloc (strlen (debug_file_directory
) + 1
1505 + (canon_dirlen
> dirlen
? canon_dirlen
: dirlen
)
1506 + strlen (".debug/")
1507 #ifdef EXTRA_DEBUG_ROOT1
1508 + strlen (EXTRA_DEBUG_ROOT1
)
1510 #ifdef EXTRA_DEBUG_ROOT2
1511 + strlen (EXTRA_DEBUG_ROOT2
)
1515 if (debugfile
== NULL
)
1516 goto found
; /* Actually this returns NULL. */
1518 /* First try in the same directory as the original file.
1520 FIXME: Strictly speaking if we are using the build-id method,
1521 (ie include_dirs == FALSE) then we should only check absolute
1522 paths, not relative ones like this one (and the next one).
1523 The check is left in however as this allows the binutils
1524 testsuite to exercise this feature without having to install
1525 a file into the root filesystem. (See binutils/testsuite/
1526 binutils-all/objdump.exp for the test). */
1527 sprintf (debugfile
, "%s%s", dir
, base
);
1528 if (check_func (debugfile
, func_data
))
1531 /* Then try in a subdirectory called .debug. */
1532 sprintf (debugfile
, "%s.debug/%s", dir
, base
);
1533 if (check_func (debugfile
, func_data
))
1536 #ifdef EXTRA_DEBUG_ROOT1
1537 /* Try the first extra debug file root. */
1538 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT1
,
1539 include_dirs
? canon_dir
: "/", base
);
1540 if (check_func (debugfile
, func_data
))
1544 #ifdef EXTRA_DEBUG_ROOT2
1545 /* Try the second extra debug file root. */
1546 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT2
,
1547 include_dirs
? canon_dir
: "/", base
);
1548 if (check_func (debugfile
, func_data
))
1552 /* Then try in the global debugfile directory. */
1553 strcpy (debugfile
, debug_file_directory
);
1554 dirlen
= strlen (debug_file_directory
) - 1;
1558 && debug_file_directory
[dirlen
] != '/'
1559 && canon_dir
[0] != '/')
1560 strcat (debugfile
, "/");
1561 strcat (debugfile
, canon_dir
);
1565 if (dirlen
> 0 && debug_file_directory
[dirlen
] != '/')
1566 strcat (debugfile
, "/");
1568 strcat (debugfile
, base
);
1570 if (check_func (debugfile
, func_data
))
1573 /* Failed to find the file. */
1586 bfd_follow_gnu_debuglink
1589 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1592 Takes a BFD and searches it for a .gnu_debuglink section. If this
1593 section is found, it examines the section for the name and checksum
1594 of a '.debug' file containing auxiliary debugging information. It
1595 then searches the filesystem for this .debug file in some standard
1596 locations, including the directory tree rooted at @var{dir}, and if
1597 found returns the full filename.
1599 If @var{dir} is NULL, the search will take place starting at
1600 the current directory.
1602 Returns <<NULL>> on any errors or failure to locate the .debug
1603 file, otherwise a pointer to a heap-allocated string
1604 containing the filename. The caller is responsible for
1605 freeing this string.
1609 bfd_follow_gnu_debuglink (bfd
*abfd
, const char *dir
)
1611 unsigned long crc32
;
1613 return find_separate_debug_file (abfd
, dir
, true,
1614 bfd_get_debug_link_info_1
,
1615 separate_debug_file_exists
, &crc32
);
1618 /* Helper for bfd_follow_gnu_debugaltlink. It just returns the name
1619 of the separate debug file. */
1622 get_alt_debug_link_info_shim (bfd
* abfd
, void *unused ATTRIBUTE_UNUSED
)
1625 bfd_byte
*buildid
= NULL
;
1626 char *result
= bfd_get_alt_debug_link_info (abfd
, &len
, &buildid
);
1635 bfd_follow_gnu_debugaltlink
1638 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1641 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1642 section is found, it examines the section for the name of a file
1643 containing auxiliary debugging information. It then searches the
1644 filesystem for this file in a set of standard locations, including
1645 the directory tree rooted at @var{dir}, and if found returns the
1648 If @var{dir} is NULL, the search will take place starting at
1649 the current directory.
1651 Returns <<NULL>> on any errors or failure to locate the debug
1652 file, otherwise a pointer to a heap-allocated string
1653 containing the filename. The caller is responsible for
1654 freeing this string.
1658 bfd_follow_gnu_debugaltlink (bfd
*abfd
, const char *dir
)
1660 return find_separate_debug_file (abfd
, dir
, true,
1661 get_alt_debug_link_info_shim
,
1662 separate_alt_debug_file_exists
,
1668 bfd_create_gnu_debuglink_section
1671 struct bfd_section *bfd_create_gnu_debuglink_section
1672 (bfd *abfd, const char *filename);
1675 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The
1676 section is sized to be big enough to contain a link to the specified
1679 A pointer to the new section is returned if all is ok. Otherwise
1680 <<NULL>> is returned and bfd_error is set.
1684 bfd_create_gnu_debuglink_section (bfd
*abfd
, const char *filename
)
1687 bfd_size_type debuglink_size
;
1690 if (abfd
== NULL
|| filename
== NULL
)
1692 bfd_set_error (bfd_error_invalid_operation
);
1696 /* Strip off any path components in filename. */
1697 filename
= lbasename (filename
);
1699 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1702 /* Section already exists. */
1703 bfd_set_error (bfd_error_invalid_operation
);
1707 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DEBUGGING
;
1708 sect
= bfd_make_section_with_flags (abfd
, GNU_DEBUGLINK
, flags
);
1712 /* Compute the size of the section. Allow for the CRC after the filename,
1713 and padding so that it will start on a 4-byte boundary. */
1714 debuglink_size
= strlen (filename
) + 1;
1715 debuglink_size
+= 3;
1716 debuglink_size
&= ~3;
1717 debuglink_size
+= 4;
1719 if (!bfd_set_section_size (sect
, debuglink_size
))
1720 /* XXX Should we delete the section from the bfd ? */
1723 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1724 Note - despite the name of the function being called, we are
1725 setting an alignment power, not a byte alignment value. */
1726 bfd_set_section_alignment (sect
, 2);
1734 bfd_fill_in_gnu_debuglink_section
1737 bool bfd_fill_in_gnu_debuglink_section
1738 (bfd *abfd, struct bfd_section *sect, const char *filename);
1741 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1742 and fills in the contents of the section to contain a link to the
1743 specified @var{filename}. The filename should be relative to the
1746 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1747 and bfd_error is set.
1751 bfd_fill_in_gnu_debuglink_section (bfd
*abfd
,
1752 struct bfd_section
*sect
,
1753 const char *filename
)
1755 bfd_size_type debuglink_size
;
1756 unsigned long crc32
;
1758 bfd_size_type crc_offset
;
1760 unsigned char buffer
[8 * 1024];
1764 if (abfd
== NULL
|| sect
== NULL
|| filename
== NULL
)
1766 bfd_set_error (bfd_error_invalid_operation
);
1770 /* Make sure that we can read the file.
1771 XXX - Should we attempt to locate the debug info file using the same
1772 algorithm as gdb ? At the moment, since we are creating the
1773 .gnu_debuglink section, we insist upon the user providing us with a
1774 correct-for-section-creation-time path, but this need not conform to
1775 the gdb location algorithm. */
1776 handle
= _bfd_real_fopen (filename
, FOPEN_RB
);
1779 bfd_set_error (bfd_error_system_call
);
1784 while ((count
= fread (buffer
, 1, sizeof buffer
, handle
)) > 0)
1785 crc32
= bfd_calc_gnu_debuglink_crc32 (crc32
, buffer
, count
);
1788 /* Strip off any path components in filename,
1789 now that we no longer need them. */
1790 filename
= lbasename (filename
);
1792 filelen
= strlen (filename
);
1793 debuglink_size
= filelen
+ 1;
1794 debuglink_size
+= 3;
1795 debuglink_size
&= ~3;
1796 debuglink_size
+= 4;
1798 contents
= (char *) bfd_malloc (debuglink_size
);
1799 if (contents
== NULL
)
1801 /* XXX Should we delete the section from the bfd ? */
1805 crc_offset
= debuglink_size
- 4;
1806 memcpy (contents
, filename
, filelen
);
1807 memset (contents
+ filelen
, 0, crc_offset
- filelen
);
1809 bfd_put_32 (abfd
, crc32
, contents
+ crc_offset
);
1811 if (! bfd_set_section_contents (abfd
, sect
, contents
, 0, debuglink_size
))
1813 /* XXX Should we delete the section from the bfd ? */
1826 struct bfd_build_id * get_build_id (bfd *abfd);
1829 Finds the build-id associated with @var{abfd}. If the build-id is
1830 extracted from the note section then a build-id structure is built
1831 for it, using memory allocated to @var{abfd}, and this is then
1832 attached to the @var{abfd}.
1834 Returns a pointer to the build-id structure if a build-id could be
1835 found. If no build-id is found NULL is returned and error code is
1839 static struct bfd_build_id
*
1840 get_build_id (bfd
*abfd
)
1842 struct bfd_build_id
*build_id
;
1843 Elf_Internal_Note inote
;
1844 Elf_External_Note
*enote
;
1851 if (abfd
->build_id
&& abfd
->build_id
->size
> 0)
1852 /* Save some time by using the already computed build-id. */
1853 return (struct bfd_build_id
*) abfd
->build_id
;
1855 sect
= bfd_get_section_by_name (abfd
, ".note.gnu.build-id");
1858 bfd_set_error (bfd_error_no_debug_section
);
1862 size
= bfd_section_size (sect
);
1863 /* FIXME: Should we support smaller build-id notes ? */
1866 bfd_set_error (bfd_error_invalid_operation
);
1870 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1876 /* FIXME: Paranoia - allow for compressed build-id sections.
1877 Maybe we should complain if this size is different from
1878 the one obtained above... */
1879 size
= bfd_section_size (sect
);
1880 if (size
< sizeof (Elf_External_Note
))
1882 bfd_set_error (bfd_error_invalid_operation
);
1887 enote
= (Elf_External_Note
*) contents
;
1888 inote
.type
= H_GET_32 (abfd
, enote
->type
);
1889 inote
.namesz
= H_GET_32 (abfd
, enote
->namesz
);
1890 inote
.namedata
= enote
->name
;
1891 inote
.descsz
= H_GET_32 (abfd
, enote
->descsz
);
1892 inote
.descdata
= inote
.namedata
+ BFD_ALIGN (inote
.namesz
, 4);
1893 /* FIXME: Should we check for extra notes in this section ? */
1895 if (inote
.descsz
<= 0
1896 || inote
.type
!= NT_GNU_BUILD_ID
1897 || inote
.namesz
!= 4 /* sizeof "GNU" */
1898 || !startswith (inote
.namedata
, "GNU")
1899 || inote
.descsz
> 0x7ffffffe
1900 || size
< (12 + BFD_ALIGN (inote
.namesz
, 4) + inote
.descsz
))
1903 bfd_set_error (bfd_error_invalid_operation
);
1907 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) + inote
.descsz
);
1908 if (build_id
== NULL
)
1914 build_id
->size
= inote
.descsz
;
1915 memcpy (build_id
->data
, inote
.descdata
, inote
.descsz
);
1916 abfd
->build_id
= build_id
;
1927 char * get_build_id_name (bfd *abfd, void *build_id_out_p)
1930 Searches @var{abfd} for a build-id, and then constructs a pathname
1931 from it. The path is computed as .build-id/NN/NN+NN.debug where
1932 NNNN+NN is the build-id value as a hexadecimal string.
1934 Returns the constructed filename or NULL upon error.
1935 It is the caller's responsibility to free the memory used to hold the
1937 If a filename is returned then the @var{build_id_out_p}
1938 parameter (which points to a @code{struct bfd_build_id}
1939 pointer) is set to a pointer to the build_id structure.
1943 get_build_id_name (bfd
*abfd
, void *build_id_out_p
)
1945 struct bfd_build_id
**build_id_out
= build_id_out_p
;
1946 struct bfd_build_id
*build_id
;
1952 if (abfd
== NULL
|| bfd_get_filename (abfd
) == NULL
|| build_id_out
== NULL
)
1954 bfd_set_error (bfd_error_invalid_operation
);
1958 build_id
= get_build_id (abfd
);
1959 if (build_id
== NULL
)
1962 /* Compute the debug pathname corresponding to the build-id. */
1963 name
= bfd_malloc (strlen (".build-id/") + build_id
->size
* 2 + 2 + strlen (".debug"));
1966 bfd_set_error (bfd_error_no_memory
);
1973 n
+= sprintf (n
, ".build-id/");
1974 n
+= sprintf (n
, "%02x", (unsigned) *d
++); s
--;
1975 n
+= sprintf (n
, "/");
1977 n
+= sprintf (n
, "%02x", (unsigned) *d
++);
1978 n
+= sprintf (n
, ".debug");
1980 *build_id_out
= build_id
;
1989 bool check_build_id_file (char *name, void *buildid_p);
1992 Checks to see if @var{name} is a readable file and if its build-id
1993 matches @var{buildid}.
1995 Returns TRUE if the file exists, is readable, and contains a
1996 build-id which matches the build-id pointed at by
1997 @var{build_id_p} (which is really a @code{struct bfd_build_id **}).
2001 check_build_id_file (const char *name
, void *buildid_p
)
2003 struct bfd_build_id
*orig_build_id
;
2004 struct bfd_build_id
*build_id
;
2009 BFD_ASSERT (buildid_p
);
2011 file
= bfd_openr (name
, NULL
);
2015 /* If the file is an archive, process all of its elements. */
2016 if (! bfd_check_format (file
, bfd_object
))
2022 build_id
= get_build_id (file
);
2023 if (build_id
== NULL
)
2029 orig_build_id
= *(struct bfd_build_id
**) buildid_p
;
2031 result
= build_id
->size
== orig_build_id
->size
2032 && memcmp (build_id
->data
, orig_build_id
->data
, build_id
->size
) == 0;
2034 (void) bfd_close (file
);
2041 bfd_follow_build_id_debuglink
2044 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
2047 Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2048 If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2049 note, which should be a hexadecimal value @var{NNNN+NN} (for
2050 32+ hex digits). It then searches the filesystem for a file named
2051 @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2052 including the directory tree rooted at @var{dir}. The filename
2053 of the first matching file to be found is returned. A matching
2054 file should contain a .note.gnu.build-id section with the same
2055 @var{NNNN+NN} note as @var{abfd}, although this check is currently
2058 If @var{dir} is NULL, the search will take place starting at
2059 the current directory.
2061 Returns <<NULL>> on any errors or failure to locate the debug
2062 file, otherwise a pointer to a heap-allocated string
2063 containing the filename. The caller is responsible for
2064 freeing this string.
2068 bfd_follow_build_id_debuglink (bfd
*abfd
, const char *dir
)
2070 struct bfd_build_id
*build_id
;
2072 return find_separate_debug_file (abfd
, dir
, false,
2074 check_build_id_file
, &build_id
);
2082 const char *bfd_set_filename (bfd *abfd, const char *filename);
2085 Set the filename of @var{abfd}, copying the FILENAME parameter to
2086 bfd_alloc'd memory owned by @var{abfd}. Returns a pointer the
2087 newly allocated name, or NULL if the allocation failed.
2091 bfd_set_filename (bfd
*abfd
, const char *filename
)
2093 size_t len
= strlen (filename
) + 1;
2094 char *n
= bfd_alloc (abfd
, len
);
2099 if (abfd
->filename
!= NULL
)
2101 /* PR 29389. If we attempt to rename a file that has been closed due
2102 to caching, then we will not be able to reopen it later on. */
2103 if (abfd
->iostream
== NULL
&& (abfd
->flags
& BFD_CLOSED_BY_CACHE
))
2105 bfd_set_error (bfd_error_invalid_operation
);
2109 /* Similarly if we attempt to close a renamed file because the
2110 cache is now full, we will not be able to reopen it later on. */
2111 if (abfd
->iostream
!= NULL
)
2112 abfd
->cacheable
= 0;
2115 memcpy (n
, filename
, len
);