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. */
42 Opening and closing BFDs
45 Functions for opening and closing
48 /* Counters used to initialize the bfd identifier. */
50 static unsigned int bfd_id_counter
= 0;
51 static unsigned int bfd_reserved_id_counter
= 0;
55 .{* Set to N to open the next N BFDs using an alternate id space. *}
56 .extern unsigned int bfd_use_reserved_id;
59 unsigned int bfd_use_reserved_id
= 0;
61 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
62 if we do that we can't use fcntl. */
69 bfd *_bfd_new_bfd (void);
72 Return a new BFD. All BFD's are allocated through this routine.
80 nbfd
= (bfd
*) bfd_zmalloc (sizeof (bfd
));
84 if (bfd_use_reserved_id
)
86 nbfd
->id
= --bfd_reserved_id_counter
;
87 --bfd_use_reserved_id
;
90 nbfd
->id
= bfd_id_counter
++;
92 nbfd
->memory
= objalloc_create ();
93 if (nbfd
->memory
== NULL
)
95 bfd_set_error (bfd_error_no_memory
);
100 nbfd
->arch_info
= &bfd_default_arch_struct
;
102 if (!bfd_hash_table_init_n (& nbfd
->section_htab
, bfd_section_hash_newfunc
,
103 sizeof (struct section_hash_entry
), 13))
105 objalloc_free ((struct objalloc
*) nbfd
->memory
);
110 nbfd
->archive_plugin_fd
= -1;
115 static const struct bfd_iovec opncls_iovec
;
119 _bfd_new_bfd_contained_in
122 bfd *_bfd_new_bfd_contained_in (bfd *);
125 Allocate a new BFD as a member of archive OBFD.
129 _bfd_new_bfd_contained_in (bfd
*obfd
)
133 /* Nested archives in bims are unsupported. */
134 if ((obfd
->flags
& BFD_IN_MEMORY
) != 0)
136 bfd_set_error (bfd_error_malformed_archive
);
139 nbfd
= _bfd_new_bfd ();
142 nbfd
->xvec
= obfd
->xvec
;
143 nbfd
->iovec
= obfd
->iovec
;
144 if (obfd
->iovec
== &opncls_iovec
)
145 nbfd
->iostream
= obfd
->iostream
;
146 nbfd
->my_archive
= obfd
;
147 nbfd
->direction
= read_direction
;
148 nbfd
->target_defaulted
= obfd
->target_defaulted
;
149 nbfd
->lto_output
= obfd
->lto_output
;
150 nbfd
->no_export
= obfd
->no_export
;
157 _bfd_delete_bfd (bfd
*abfd
)
159 /* Give the target _bfd_free_cached_info a chance to free memory. */
160 if (abfd
->memory
&& abfd
->xvec
)
161 bfd_free_cached_info (abfd
);
163 /* The target _bfd_free_cached_info may not have done anything.. */
166 bfd_hash_table_free (&abfd
->section_htab
);
167 objalloc_free ((struct objalloc
*) abfd
->memory
);
170 free ((char *) bfd_get_filename (abfd
));
172 free (abfd
->arelt_data
);
178 _bfd_free_cached_info
181 bool _bfd_free_cached_info (bfd *);
184 Free objalloc memory.
188 _bfd_free_cached_info (bfd
*abfd
)
192 const char *filename
= bfd_get_filename (abfd
);
195 /* We can't afford to lose the bfd filename when freeing
196 abfd->memory, because that would kill the cache.c scheme
197 of closing and reopening files in order to limit the
198 number of open files. To reopen, you need the filename.
199 And indeed _bfd_compute_and_write_armap calls
200 _bfd_free_cached_info to free up space used by symbols
201 and by check_format_matches. Which we want to continue
202 doing to handle very large archives. Later the archive
203 elements are copied, which might require reopening files.
204 We also want to keep using objalloc memory for the
205 filename since that allows the name to be updated
206 without either leaking memory or implementing some sort
207 of reference counted string for copies of the filename. */
208 size_t len
= strlen (filename
) + 1;
209 char *copy
= bfd_malloc (len
);
212 memcpy (copy
, filename
, len
);
213 abfd
->filename
= copy
;
215 bfd_hash_table_free (&abfd
->section_htab
);
216 objalloc_free ((struct objalloc
*) abfd
->memory
);
218 abfd
->sections
= NULL
;
219 abfd
->section_last
= NULL
;
220 abfd
->outsymbols
= NULL
;
221 abfd
->tdata
.any
= NULL
;
222 abfd
->usrdata
= NULL
;
234 bfd *bfd_fopen (const char *filename, const char *target,
235 const char *mode, int fd);
238 Open the file @var{filename} with the target @var{target}.
239 Return a pointer to the created BFD. If @var{fd} is not -1,
240 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
241 is used. @var{mode} is passed directly to <<fopen>> or
244 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
247 The new BFD is marked as cacheable iff @var{fd} is -1.
249 If <<NULL>> is returned then an error has occured. Possible errors
250 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
251 <<system_call>> error.
253 On error, @var{fd} is always closed.
255 A copy of the @var{filename} argument is stored in the newly created
256 BFD. It can be accessed via the bfd_get_filename() macro.
260 bfd_fopen (const char *filename
, const char *target
, const char *mode
, int fd
)
263 const bfd_target
*target_vec
;
265 nbfd
= _bfd_new_bfd ();
273 target_vec
= bfd_find_target (target
, nbfd
);
274 if (target_vec
== NULL
)
278 _bfd_delete_bfd (nbfd
);
284 nbfd
->iostream
= fdopen (fd
, mode
);
287 nbfd
->iostream
= _bfd_real_fopen (filename
, mode
);
288 if (nbfd
->iostream
== NULL
)
290 bfd_set_error (bfd_error_system_call
);
293 _bfd_delete_bfd (nbfd
);
297 /* OK, put everything where it belongs. */
299 /* PR 11983: Do not cache the original filename, but
300 rather make a copy - the original might go away. */
301 if (!bfd_set_filename (nbfd
, filename
))
303 fclose (nbfd
->iostream
);
304 _bfd_delete_bfd (nbfd
);
308 /* Figure out whether the user is opening the file for reading,
309 writing, or both, by looking at the MODE argument. */
310 if ((mode
[0] == 'r' || mode
[0] == 'w' || mode
[0] == 'a')
312 nbfd
->direction
= both_direction
;
313 else if (mode
[0] == 'r')
314 nbfd
->direction
= read_direction
;
316 nbfd
->direction
= write_direction
;
318 if (!bfd_cache_init (nbfd
))
320 fclose (nbfd
->iostream
);
321 _bfd_delete_bfd (nbfd
);
324 nbfd
->opened_once
= true;
326 /* If we opened the file by name, mark it cacheable; we can close it
327 and reopen it later. However, if a file descriptor was provided,
328 then it may have been opened with special flags that make it
329 unsafe to close and reopen the file. */
331 (void) bfd_set_cacheable (nbfd
, true);
341 bfd *bfd_openr (const char *filename, const char *target);
344 Open the file @var{filename} (using <<fopen>>) with the target
345 @var{target}. Return a pointer to the created BFD.
347 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
350 If <<NULL>> is returned then an error has occured. Possible errors
351 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
352 <<system_call>> error.
354 A copy of the @var{filename} argument is stored in the newly created
355 BFD. It can be accessed via the bfd_get_filename() macro.
359 bfd_openr (const char *filename
, const char *target
)
361 return bfd_fopen (filename
, target
, FOPEN_RB
, -1);
364 /* Don't try to `optimize' this function:
366 o - We lock using stack space so that interrupting the locking
367 won't cause a storage leak.
368 o - We open the file stream last, since we don't want to have to
369 close it if anything goes wrong. Closing the stream means closing
370 the file descriptor too, even though we didn't open it. */
376 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
379 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
380 <<fopen>>. It opens a BFD on a file already described by the
383 When the file is later <<bfd_close>>d, the file descriptor will
384 be closed. If the caller desires that this file descriptor be
385 cached by BFD (opened as needed, closed as needed to free
386 descriptors for other opens), with the supplied @var{fd} used as
387 an initial file descriptor (but subject to closure at any time),
388 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
389 is to assume no caching; the file descriptor will remain open
390 until <<bfd_close>>, and will not be affected by BFD operations
393 Possible errors are <<bfd_error_no_memory>>,
394 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
396 On error, @var{fd} is closed.
398 A copy of the @var{filename} argument is stored in the newly created
399 BFD. It can be accessed via the bfd_get_filename() macro.
403 bfd_fdopenr (const char *filename
, const char *target
, int fd
)
406 #if defined(HAVE_FCNTL) && defined(F_GETFL)
410 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
411 mode
= FOPEN_RUB
; /* Assume full access. */
413 fdflags
= fcntl (fd
, F_GETFL
, NULL
);
420 bfd_set_error (bfd_error_system_call
);
424 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
425 switch (fdflags
& (O_ACCMODE
))
427 case O_RDONLY
: mode
= FOPEN_RB
; break;
428 case O_WRONLY
: mode
= FOPEN_RUB
; break;
429 case O_RDWR
: mode
= FOPEN_RUB
; break;
434 return bfd_fopen (filename
, target
, mode
, fd
);
442 bfd *bfd_fdopenw (const char *filename, const char *target, int fd);
445 <<bfd_fdopenw>> is exactly like <<bfd_fdopenr>> with the exception that
446 the resulting BFD is suitable for output.
450 bfd_fdopenw (const char *filename
, const char *target
, int fd
)
452 bfd
*out
= bfd_fdopenr (filename
, target
, fd
);
456 if (!bfd_write_p (out
))
459 _bfd_delete_bfd (out
);
461 bfd_set_error (bfd_error_invalid_operation
);
464 out
->direction
= write_direction
;
475 bfd *bfd_openstreamr (const char * filename, const char * target,
479 Open a BFD for read access on an existing stdio stream. When
480 the BFD is passed to <<bfd_close>>, the stream will be closed.
482 A copy of the @var{filename} argument is stored in the newly created
483 BFD. It can be accessed via the bfd_get_filename() macro.
487 bfd_openstreamr (const char *filename
, const char *target
, void *streamarg
)
489 FILE *stream
= (FILE *) streamarg
;
491 const bfd_target
*target_vec
;
493 nbfd
= _bfd_new_bfd ();
497 target_vec
= bfd_find_target (target
, nbfd
);
498 if (target_vec
== NULL
)
500 _bfd_delete_bfd (nbfd
);
504 nbfd
->iostream
= stream
;
505 /* PR 11983: Do not cache the original filename, but
506 rather make a copy - the original might go away. */
507 if (!bfd_set_filename (nbfd
, filename
))
509 _bfd_delete_bfd (nbfd
);
512 nbfd
->direction
= read_direction
;
514 if (! bfd_cache_init (nbfd
))
516 _bfd_delete_bfd (nbfd
);
528 bfd *bfd_openr_iovec (const char *filename, const char *target,
529 void *(*open_func) (struct bfd *nbfd,
532 file_ptr (*pread_func) (struct bfd *nbfd,
537 int (*close_func) (struct bfd *nbfd,
539 int (*stat_func) (struct bfd *abfd,
544 Create and return a BFD backed by a read-only @var{stream}.
545 The @var{stream} is created using @var{open_func}, accessed using
546 @var{pread_func} and destroyed using @var{close_func}.
548 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
551 Calls @var{open_func} (which can call <<bfd_zalloc>> and
552 <<bfd_get_filename>>) to obtain the read-only stream backing
553 the BFD. @var{open_func} either succeeds returning the
554 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
555 (setting <<bfd_error>>).
557 Calls @var{pread_func} to request @var{nbytes} of data from
558 @var{stream} starting at @var{offset} (e.g., via a call to
559 <<bfd_read>>). @var{pread_func} either succeeds returning the
560 number of bytes read (which can be less than @var{nbytes} when
561 end-of-file), or fails returning -1 (setting <<bfd_error>>).
563 Calls @var{close_func} when the BFD is later closed using
564 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
565 fails returning -1 (setting <<bfd_error>>).
567 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
568 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
569 on success, or returns -1 on failure (setting <<bfd_error>>).
571 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
572 occurred. Possible errors are <<bfd_error_no_memory>>,
573 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
575 A copy of the @var{filename} argument is stored in the newly created
576 BFD. It can be accessed via the bfd_get_filename() macro.
582 file_ptr (*pread
) (struct bfd
*abfd
, void *stream
, void *buf
,
583 file_ptr nbytes
, file_ptr offset
);
584 int (*close
) (struct bfd
*abfd
, void *stream
);
585 int (*stat
) (struct bfd
*abfd
, void *stream
, struct stat
*sb
);
590 opncls_btell (struct bfd
*abfd
)
592 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
597 opncls_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
599 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
602 case SEEK_SET
: vec
->where
= offset
; break;
603 case SEEK_CUR
: vec
->where
+= offset
; break;
604 case SEEK_END
: return -1;
610 opncls_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
612 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
613 file_ptr nread
= (vec
->pread
) (abfd
, vec
->stream
, buf
, nbytes
, vec
->where
);
622 opncls_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
623 const void *where ATTRIBUTE_UNUSED
,
624 file_ptr nbytes ATTRIBUTE_UNUSED
)
630 opncls_bclose (struct bfd
*abfd
)
632 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
633 /* Since the VEC's memory is bound to the bfd deleting the bfd will
637 if (vec
->close
!= NULL
)
638 status
= (vec
->close
) (abfd
, vec
->stream
);
639 abfd
->iostream
= NULL
;
644 opncls_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
650 opncls_bstat (struct bfd
*abfd
, struct stat
*sb
)
652 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
654 memset (sb
, 0, sizeof (*sb
));
655 if (vec
->stat
== NULL
)
658 return (vec
->stat
) (abfd
, vec
->stream
, sb
);
662 opncls_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
663 void *addr ATTRIBUTE_UNUSED
,
664 bfd_size_type len ATTRIBUTE_UNUSED
,
665 int prot ATTRIBUTE_UNUSED
,
666 int flags ATTRIBUTE_UNUSED
,
667 file_ptr offset ATTRIBUTE_UNUSED
,
668 void **map_addr ATTRIBUTE_UNUSED
,
669 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
674 static const struct bfd_iovec opncls_iovec
=
676 &opncls_bread
, &opncls_bwrite
, &opncls_btell
, &opncls_bseek
,
677 &opncls_bclose
, &opncls_bflush
, &opncls_bstat
, &opncls_bmmap
681 bfd_openr_iovec (const char *filename
, const char *target
,
682 void *(*open_p
) (struct bfd
*, void *),
684 file_ptr (*pread_p
) (struct bfd
*, void *, void *,
686 int (*close_p
) (struct bfd
*, void *),
687 int (*stat_p
) (struct bfd
*, void *, struct stat
*))
690 const bfd_target
*target_vec
;
694 nbfd
= _bfd_new_bfd ();
698 target_vec
= bfd_find_target (target
, nbfd
);
699 if (target_vec
== NULL
)
701 _bfd_delete_bfd (nbfd
);
705 /* PR 11983: Do not cache the original filename, but
706 rather make a copy - the original might go away. */
707 if (!bfd_set_filename (nbfd
, filename
))
709 _bfd_delete_bfd (nbfd
);
712 nbfd
->direction
= read_direction
;
714 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
715 stream
= (*open_p
) (nbfd
, open_closure
);
718 _bfd_delete_bfd (nbfd
);
722 vec
= (struct opncls
*) bfd_zalloc (nbfd
, sizeof (struct opncls
));
723 vec
->stream
= stream
;
724 vec
->pread
= pread_p
;
725 vec
->close
= close_p
;
728 nbfd
->iovec
= &opncls_iovec
;
729 nbfd
->iostream
= vec
;
734 /* bfd_openw -- open for writing.
735 Returns a pointer to a freshly-allocated BFD on success, or NULL.
737 See comment by bfd_fdopenr before you try to modify this function. */
744 bfd *bfd_openw (const char *filename, const char *target);
747 Create a BFD, associated with file @var{filename}, using the
748 file format @var{target}, and return a pointer to it.
750 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
751 <<bfd_error_invalid_target>>.
753 A copy of the @var{filename} argument is stored in the newly created
754 BFD. It can be accessed via the bfd_get_filename() macro.
758 bfd_openw (const char *filename
, const char *target
)
761 const bfd_target
*target_vec
;
763 /* nbfd has to point to head of malloc'ed block so that bfd_close may
764 reclaim it correctly. */
765 nbfd
= _bfd_new_bfd ();
769 target_vec
= bfd_find_target (target
, nbfd
);
770 if (target_vec
== NULL
)
772 _bfd_delete_bfd (nbfd
);
776 /* PR 11983: Do not cache the original filename, but
777 rather make a copy - the original might go away. */
778 if (!bfd_set_filename (nbfd
, filename
))
780 _bfd_delete_bfd (nbfd
);
783 nbfd
->direction
= write_direction
;
785 if (bfd_open_file (nbfd
) == NULL
)
787 /* File not writeable, etc. */
788 bfd_set_error (bfd_error_system_call
);
789 _bfd_delete_bfd (nbfd
);
798 bfd_elf_bfd_from_remote_memory
801 bfd *bfd_elf_bfd_from_remote_memory
802 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep,
803 int (*target_read_memory)
804 (bfd_vma vma, bfd_byte *myaddr, bfd_size_type len));
807 Create a new BFD as if by bfd_openr. Rather than opening a
808 file, reconstruct an ELF file by reading the segments out of
809 remote memory based on the ELF file header at EHDR_VMA and the
810 ELF program headers it points to. If non-zero, SIZE is the
811 known extent of the object. If not null, *LOADBASEP is filled
812 in with the difference between the VMAs from which the
813 segments were read, and the VMAs the file headers (and hence
814 BFD's idea of each section's VMA) put them at.
816 The function TARGET_READ_MEMORY is called to copy LEN bytes
817 from the remote memory at target address VMA into the local
818 buffer at MYADDR; it should return zero on success or an
819 errno code on failure. TEMPL must be a BFD for an ELF
820 target with the word size and byte order found in the remote
825 bfd_elf_bfd_from_remote_memory
830 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
832 if (bfd_get_flavour (templ
) != bfd_target_elf_flavour
)
834 bfd_set_error (bfd_error_invalid_operation
);
837 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
838 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
842 _maybe_make_executable (bfd
* abfd
)
844 /* If the file was open for writing and is now executable,
846 if (abfd
->direction
== write_direction
847 && (abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
851 if (stat (bfd_get_filename (abfd
), &buf
) == 0
852 /* Do not attempt to change non-regular files. This is
853 here especially for configure scripts and kernel builds
854 which run tests with "ld [...] -o /dev/null". */
855 && S_ISREG(buf
.st_mode
))
857 unsigned int mask
= umask (0);
860 chmod (bfd_get_filename (abfd
),
862 & (buf
.st_mode
| ((S_IXUSR
| S_IXGRP
| S_IXOTH
) &~ mask
))));
872 bool bfd_close (bfd *abfd);
875 Close a BFD. If the BFD was open for writing, then pending
876 operations are completed and the file written out and closed.
877 If the created file is executable, then <<chmod>> is called
880 All memory attached to the BFD is released.
882 The file descriptor associated with the BFD is closed (even
883 if it was passed in to BFD by <<bfd_fdopenr>>).
885 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
889 bfd_close (bfd
*abfd
)
891 bool ret
= (!bfd_write_p (abfd
)
892 || BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)));
894 return bfd_close_all_done (abfd
) && ret
;
902 bool bfd_close_all_done (bfd *);
905 Close a BFD. Differs from <<bfd_close>> since it does not
906 complete any pending operations. This routine would be used
907 if the application had just used BFD for swapping and didn't
908 want to use any of the writing code.
910 If the created file is executable, then <<chmod>> is called
913 All memory attached to the BFD is released.
915 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
919 bfd_close_all_done (bfd
*abfd
)
921 bool ret
= BFD_SEND (abfd
, _close_and_cleanup
, (abfd
));
923 if (ret
&& abfd
->iovec
!= NULL
)
925 ret
= abfd
->iovec
->bclose (abfd
) == 0;
928 _maybe_make_executable (abfd
);
931 _bfd_delete_bfd (abfd
);
932 free (_bfd_error_buf
);
933 _bfd_error_buf
= NULL
;
943 bfd *bfd_create (const char *filename, bfd *templ);
946 Create a new BFD in the manner of <<bfd_openw>>, but without
947 opening a file. The new BFD takes the target from the target
948 used by @var{templ}. The format is always set to <<bfd_object>>.
950 A copy of the @var{filename} argument is stored in the newly created
951 BFD. It can be accessed via the bfd_get_filename() macro.
955 bfd_create (const char *filename
, bfd
*templ
)
959 nbfd
= _bfd_new_bfd ();
962 /* PR 11983: Do not cache the original filename, but
963 rather make a copy - the original might go away. */
964 if (!bfd_set_filename (nbfd
, filename
))
966 _bfd_delete_bfd (nbfd
);
970 nbfd
->xvec
= templ
->xvec
;
971 nbfd
->direction
= no_direction
;
972 bfd_set_format (nbfd
, bfd_object
);
982 bool bfd_make_writable (bfd *abfd);
985 Takes a BFD as created by <<bfd_create>> and converts it
986 into one like as returned by <<bfd_openw>>. It does this
987 by converting the BFD to BFD_IN_MEMORY. It's assumed that
988 you will call <<bfd_make_readable>> on this bfd later.
990 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
994 bfd_make_writable (bfd
*abfd
)
996 struct bfd_in_memory
*bim
;
998 if (abfd
->direction
!= no_direction
)
1000 bfd_set_error (bfd_error_invalid_operation
);
1004 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
1006 return false; /* bfd_error already set. */
1007 abfd
->iostream
= bim
;
1008 /* bfd_write will grow these as needed. */
1012 abfd
->flags
|= BFD_IN_MEMORY
;
1013 abfd
->iovec
= &_bfd_memory_iovec
;
1015 abfd
->direction
= write_direction
;
1026 bool bfd_make_readable (bfd *abfd);
1029 Takes a BFD as created by <<bfd_create>> and
1030 <<bfd_make_writable>> and converts it into one like as
1031 returned by <<bfd_openr>>. It does this by writing the
1032 contents out to the memory buffer, then reversing the
1035 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
1038 bfd_make_readable (bfd
*abfd
)
1040 if (abfd
->direction
!= write_direction
|| !(abfd
->flags
& BFD_IN_MEMORY
))
1042 bfd_set_error (bfd_error_invalid_operation
);
1046 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
1049 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
1052 abfd
->arch_info
= &bfd_default_arch_struct
;
1055 abfd
->format
= bfd_unknown
;
1056 abfd
->my_archive
= NULL
;
1058 abfd
->opened_once
= false;
1059 abfd
->output_has_begun
= false;
1060 abfd
->section_count
= 0;
1061 abfd
->usrdata
= NULL
;
1062 abfd
->cacheable
= false;
1063 abfd
->flags
|= BFD_IN_MEMORY
;
1064 abfd
->mtime_set
= false;
1066 abfd
->target_defaulted
= true;
1067 abfd
->direction
= read_direction
;
1070 abfd
->outsymbols
= 0;
1071 abfd
->tdata
.any
= 0;
1074 bfd_section_list_clear (abfd
);
1075 bfd_check_format (abfd
, bfd_object
);
1081 GNU Extension: separate debug-info files
1083 The idea here is that a special section called .gnu_debuglink might be
1084 embedded in a binary file, which indicates that some *other* file
1085 contains the real debugging information. This special section contains a
1086 filename and CRC32 checksum, which we read and resolve to another file,
1089 This facilitates "optional" provision of debugging information, without
1090 having to provide two complete copies of every binary object (with and
1091 without debug symbols). */
1093 #define GNU_DEBUGLINK ".gnu_debuglink"
1094 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1098 bfd_calc_gnu_debuglink_crc32
1101 uint32_t bfd_calc_gnu_debuglink_crc32
1102 (uint32_t crc, const bfd_byte *buf, bfd_size_type len);
1105 Computes a CRC value as used in the .gnu_debuglink section.
1106 Advances the previously computed @var{crc} value by computing
1107 and adding in the crc32 for @var{len} bytes of @var{buf}.
1109 Return the updated CRC32 value.
1113 bfd_calc_gnu_debuglink_crc32 (uint32_t crc
,
1114 const bfd_byte
*buf
,
1117 static const uint32_t crc32_table
[256] =
1119 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1120 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1121 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1122 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1123 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1124 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1125 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1126 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1127 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1128 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1129 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1130 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1131 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1132 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1133 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1134 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1135 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1136 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1137 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1138 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1139 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1140 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1141 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1142 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1143 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1144 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1145 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1146 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1147 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1148 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1149 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1150 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1151 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1152 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1153 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1154 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1155 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1156 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1157 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1158 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1159 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1160 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1161 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1162 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1163 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1164 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1165 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1166 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1167 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1168 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1169 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1172 const bfd_byte
*end
;
1174 crc
= ~crc
& 0xffffffff;
1175 for (end
= buf
+ len
; buf
< end
; ++ buf
)
1176 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
1177 return ~crc
& 0xffffffff;
1181 /* Extracts the filename and CRC32 value for any separate debug
1182 information file associated with @var{abfd}.
1184 The @var{crc32_out} parameter is an untyped pointer because
1185 this routine is used as a @code{get_func_type} function, but it
1186 is expected to be a uint32_t pointer.
1188 Returns the filename of the associated debug information file,
1189 or NULL if there is no such file. If the filename was found
1190 then the contents of @var{crc32_out} are updated to hold the
1191 corresponding CRC32 value for the file.
1193 The returned filename is allocated with @code{malloc}; freeing
1194 it is the responsibility of the caller. */
1197 bfd_get_debug_link_info_1 (bfd
*abfd
, void *crc32_out
)
1200 uint32_t *crc32
= crc32_out
;
1202 unsigned int crc_offset
;
1207 BFD_ASSERT (crc32_out
);
1209 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1211 if (sect
== NULL
|| (sect
->flags
& SEC_HAS_CONTENTS
) == 0)
1214 size
= bfd_section_size (sect
);
1216 /* PR 22794: Make sure that the section has a reasonable size. */
1220 if (!bfd_malloc_and_get_section (abfd
, sect
, &contents
))
1223 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1224 name
= (char *) contents
;
1225 /* PR 17597: Avoid reading off the end of the buffer. */
1226 crc_offset
= strnlen (name
, size
) + 1;
1227 crc_offset
= (crc_offset
+ 3) & ~3;
1228 if (crc_offset
+ 4 > size
)
1234 *crc32
= bfd_get_32 (abfd
, contents
+ crc_offset
);
1241 bfd_get_debug_link_info
1244 char *bfd_get_debug_link_info (bfd *abfd, uint32_t *crc32_out);
1247 Extracts the filename and CRC32 value for any separate debug
1248 information file associated with @var{abfd}.
1250 Returns the filename of the associated debug information file,
1251 or NULL if there is no such file. If the filename was found
1252 then the contents of @var{crc32_out} are updated to hold the
1253 corresponding CRC32 value for the file.
1255 The returned filename is allocated with @code{malloc}; freeing
1256 it is the responsibility of the caller.
1260 bfd_get_debug_link_info (bfd
*abfd
, uint32_t *crc32_out
)
1262 return bfd_get_debug_link_info_1 (abfd
, crc32_out
);
1267 bfd_get_alt_debug_link_info
1270 char *bfd_get_alt_debug_link_info (bfd * abfd,
1271 bfd_size_type *buildid_len,
1272 bfd_byte **buildid_out);
1275 Fetch the filename and BuildID value for any alternate debuginfo
1276 associated with @var{abfd}. Return NULL if no such info found,
1277 otherwise return filename and update @var{buildid_len} and
1278 @var{buildid_out}. The returned filename and build_id are
1279 allocated with @code{malloc}; freeing them is the responsibility
1284 bfd_get_alt_debug_link_info (bfd
* abfd
, bfd_size_type
*buildid_len
,
1285 bfd_byte
**buildid_out
)
1289 unsigned int buildid_offset
;
1294 BFD_ASSERT (buildid_len
);
1295 BFD_ASSERT (buildid_out
);
1297 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGALTLINK
);
1299 if (sect
== NULL
|| (sect
->flags
& SEC_HAS_CONTENTS
) == 0)
1302 size
= bfd_section_size (sect
);
1306 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1309 /* BuildID value is stored after the filename. */
1310 name
= (char *) contents
;
1311 buildid_offset
= strnlen (name
, size
) + 1;
1312 if (buildid_offset
>= bfd_section_size (sect
))
1315 *buildid_len
= size
- buildid_offset
;
1316 *buildid_out
= bfd_malloc (*buildid_len
);
1317 memcpy (*buildid_out
, contents
+ buildid_offset
, *buildid_len
);
1322 /* Checks to see if @var{name} is a file and if its contents match
1323 @var{crc32}, which is a pointer to a @code{uint32_t}
1326 The @var{crc32_p} parameter is an untyped pointer because this
1327 routine is used as a @code{check_func_type} function. */
1330 separate_debug_file_exists (const char *name
, void *crc32_p
)
1332 unsigned char buffer
[8 * 1024];
1333 uint32_t file_crc
= 0;
1335 bfd_size_type count
;
1339 BFD_ASSERT (crc32_p
);
1341 crc
= *(uint32_t *) crc32_p
;
1343 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1347 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
1348 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1352 return crc
== file_crc
;
1355 /* Checks to see if @var{name} is a file. */
1358 separate_alt_debug_file_exists (const char *name
, void *unused ATTRIBUTE_UNUSED
)
1364 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1373 /* Searches for a debug information file corresponding to @var{abfd}.
1375 The name of the separate debug info file is returned by the
1376 @var{get} function. This function scans various fixed locations
1377 in the filesystem, including the file tree rooted at @var{dir}.
1378 If the @var{include_dirs} parameter is true then the directory
1379 components of @var{abfd}'s filename will be included in the
1382 @var{data} is passed unmodified to the @var{get} and @var{check}
1383 functions. It is generally used to implement build-id-like
1384 matching in the callback functions.
1386 Returns the filename of the first file to be found which
1387 receives a TRUE result from the @var{check} function.
1388 Returns NULL if no valid file could be found. */
1390 typedef char * (*get_func_type
) (bfd
*, void *);
1391 typedef bool (*check_func_type
) (const char *, void *);
1394 find_separate_debug_file (bfd
*abfd
,
1395 const char *debug_file_directory
,
1397 get_func_type get_func
,
1398 check_func_type check_func
,
1406 size_t canon_dirlen
;
1409 if (debug_file_directory
== NULL
)
1410 debug_file_directory
= ".";
1412 /* BFD may have been opened from a stream. */
1413 if (bfd_get_filename (abfd
) == NULL
)
1415 bfd_set_error (bfd_error_invalid_operation
);
1419 base
= get_func (abfd
, func_data
);
1424 if (base
[0] == '\0')
1427 bfd_set_error (bfd_error_no_debug_section
);
1433 const char *fname
= bfd_get_filename (abfd
);
1434 for (dirlen
= strlen (fname
); dirlen
> 0; dirlen
--)
1435 if (IS_DIR_SEPARATOR (fname
[dirlen
- 1]))
1438 dir
= (char *) bfd_malloc (dirlen
+ 1);
1444 memcpy (dir
, fname
, dirlen
);
1449 dir
= (char *) bfd_malloc (1);
1454 /* Compute the canonical name of the bfd object with all symbolic links
1455 resolved, for use in the global debugfile directory. */
1456 canon_dir
= lrealpath (bfd_get_filename (abfd
));
1457 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
1458 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
1460 canon_dir
[canon_dirlen
] = '\0';
1462 #ifndef EXTRA_DEBUG_ROOT1
1463 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1465 #ifndef EXTRA_DEBUG_ROOT2
1466 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1469 debugfile
= (char *)
1470 bfd_malloc (strlen (debug_file_directory
) + 1
1471 + (canon_dirlen
> dirlen
? canon_dirlen
: dirlen
)
1472 + strlen (".debug/")
1473 #ifdef EXTRA_DEBUG_ROOT1
1474 + strlen (EXTRA_DEBUG_ROOT1
)
1476 #ifdef EXTRA_DEBUG_ROOT2
1477 + strlen (EXTRA_DEBUG_ROOT2
)
1481 if (debugfile
== NULL
)
1482 goto found
; /* Actually this returns NULL. */
1484 /* First try in the same directory as the original file.
1486 FIXME: Strictly speaking if we are using the build-id method,
1487 (ie include_dirs == FALSE) then we should only check absolute
1488 paths, not relative ones like this one (and the next one).
1489 The check is left in however as this allows the binutils
1490 testsuite to exercise this feature without having to install
1491 a file into the root filesystem. (See binutils/testsuite/
1492 binutils-all/objdump.exp for the test). */
1493 sprintf (debugfile
, "%s%s", dir
, base
);
1494 if (check_func (debugfile
, func_data
))
1497 /* Then try in a subdirectory called .debug. */
1498 sprintf (debugfile
, "%s.debug/%s", dir
, base
);
1499 if (check_func (debugfile
, func_data
))
1502 #ifdef EXTRA_DEBUG_ROOT1
1503 /* Try the first extra debug file root. */
1504 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT1
,
1505 include_dirs
? canon_dir
: "/", base
);
1506 if (check_func (debugfile
, func_data
))
1510 #ifdef EXTRA_DEBUG_ROOT2
1511 /* Try the second extra debug file root. */
1512 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT2
,
1513 include_dirs
? canon_dir
: "/", base
);
1514 if (check_func (debugfile
, func_data
))
1518 /* Then try in the global debugfile directory. */
1519 strcpy (debugfile
, debug_file_directory
);
1520 dirlen
= strlen (debug_file_directory
) - 1;
1524 && debug_file_directory
[dirlen
] != '/'
1525 && canon_dir
[0] != '/')
1526 strcat (debugfile
, "/");
1527 strcat (debugfile
, canon_dir
);
1531 if (dirlen
> 0 && debug_file_directory
[dirlen
] != '/')
1532 strcat (debugfile
, "/");
1534 strcat (debugfile
, base
);
1536 if (check_func (debugfile
, func_data
))
1539 /* Failed to find the file. */
1552 bfd_follow_gnu_debuglink
1555 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1558 Takes a BFD and searches it for a .gnu_debuglink section. If this
1559 section is found, it examines the section for the name and checksum
1560 of a '.debug' file containing auxiliary debugging information. It
1561 then searches the filesystem for this .debug file in some standard
1562 locations, including the directory tree rooted at @var{dir}, and if
1563 found returns the full filename.
1565 If @var{dir} is NULL, the search will take place starting at
1566 the current directory.
1568 Returns <<NULL>> on any errors or failure to locate the .debug
1569 file, otherwise a pointer to a heap-allocated string
1570 containing the filename. The caller is responsible for
1571 freeing this string.
1575 bfd_follow_gnu_debuglink (bfd
*abfd
, const char *dir
)
1579 return find_separate_debug_file (abfd
, dir
, true,
1580 bfd_get_debug_link_info_1
,
1581 separate_debug_file_exists
, &crc32
);
1584 /* Helper for bfd_follow_gnu_debugaltlink. It just returns the name
1585 of the separate debug file. */
1588 get_alt_debug_link_info_shim (bfd
* abfd
, void *unused ATTRIBUTE_UNUSED
)
1591 bfd_byte
*buildid
= NULL
;
1592 char *result
= bfd_get_alt_debug_link_info (abfd
, &len
, &buildid
);
1601 bfd_follow_gnu_debugaltlink
1604 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1607 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1608 section is found, it examines the section for the name of a file
1609 containing auxiliary debugging information. It then searches the
1610 filesystem for this file in a set of standard locations, including
1611 the directory tree rooted at @var{dir}, and if found returns the
1614 If @var{dir} is NULL, the search will take place starting at
1615 the current directory.
1617 Returns <<NULL>> on any errors or failure to locate the debug
1618 file, otherwise a pointer to a heap-allocated string
1619 containing the filename. The caller is responsible for
1620 freeing this string.
1624 bfd_follow_gnu_debugaltlink (bfd
*abfd
, const char *dir
)
1626 return find_separate_debug_file (abfd
, dir
, true,
1627 get_alt_debug_link_info_shim
,
1628 separate_alt_debug_file_exists
,
1634 bfd_create_gnu_debuglink_section
1637 struct bfd_section *bfd_create_gnu_debuglink_section
1638 (bfd *abfd, const char *filename);
1641 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The
1642 section is sized to be big enough to contain a link to the specified
1645 A pointer to the new section is returned if all is ok. Otherwise
1646 <<NULL>> is returned and bfd_error is set.
1650 bfd_create_gnu_debuglink_section (bfd
*abfd
, const char *filename
)
1653 bfd_size_type debuglink_size
;
1656 if (abfd
== NULL
|| filename
== NULL
)
1658 bfd_set_error (bfd_error_invalid_operation
);
1662 /* Strip off any path components in filename. */
1663 filename
= lbasename (filename
);
1665 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1668 /* Section already exists. */
1669 bfd_set_error (bfd_error_invalid_operation
);
1673 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DEBUGGING
;
1674 sect
= bfd_make_section_with_flags (abfd
, GNU_DEBUGLINK
, flags
);
1678 /* Compute the size of the section. Allow for the CRC after the filename,
1679 and padding so that it will start on a 4-byte boundary. */
1680 debuglink_size
= strlen (filename
) + 1;
1681 debuglink_size
+= 3;
1682 debuglink_size
&= ~3;
1683 debuglink_size
+= 4;
1685 if (!bfd_set_section_size (sect
, debuglink_size
))
1686 /* XXX Should we delete the section from the bfd ? */
1689 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1690 Note - despite the name of the function being called, we are
1691 setting an alignment power, not a byte alignment value. */
1692 bfd_set_section_alignment (sect
, 2);
1700 bfd_fill_in_gnu_debuglink_section
1703 bool bfd_fill_in_gnu_debuglink_section
1704 (bfd *abfd, struct bfd_section *sect, const char *filename);
1707 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1708 and fills in the contents of the section to contain a link to the
1709 specified @var{filename}. The filename should be absolute or
1710 relative to the current directory.
1712 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1713 and bfd_error is set.
1717 bfd_fill_in_gnu_debuglink_section (bfd
*abfd
,
1718 struct bfd_section
*sect
,
1719 const char *filename
)
1721 bfd_size_type debuglink_size
;
1724 bfd_size_type crc_offset
;
1726 unsigned char buffer
[8 * 1024];
1730 if (abfd
== NULL
|| sect
== NULL
|| filename
== NULL
)
1732 bfd_set_error (bfd_error_invalid_operation
);
1736 /* Open the linked file so that we can compute a CRC. */
1737 handle
= _bfd_real_fopen (filename
, FOPEN_RB
);
1740 bfd_set_error (bfd_error_system_call
);
1745 while ((count
= fread (buffer
, 1, sizeof buffer
, handle
)) > 0)
1746 crc32
= bfd_calc_gnu_debuglink_crc32 (crc32
, buffer
, count
);
1749 /* Strip off any path components in filename,
1750 now that we no longer need them. */
1751 filename
= lbasename (filename
);
1753 filelen
= strlen (filename
);
1754 debuglink_size
= filelen
+ 1;
1755 debuglink_size
+= 3;
1756 debuglink_size
&= ~3;
1757 debuglink_size
+= 4;
1759 contents
= (char *) bfd_malloc (debuglink_size
);
1760 if (contents
== NULL
)
1762 /* XXX Should we delete the section from the bfd ? */
1766 crc_offset
= debuglink_size
- 4;
1767 memcpy (contents
, filename
, filelen
);
1768 memset (contents
+ filelen
, 0, crc_offset
- filelen
);
1770 bfd_put_32 (abfd
, crc32
, contents
+ crc_offset
);
1772 if (! bfd_set_section_contents (abfd
, sect
, contents
, 0, debuglink_size
))
1774 /* XXX Should we delete the section from the bfd ? */
1782 /* Finds the build-id associated with @var{abfd}. If the build-id is
1783 extracted from the note section then a build-id structure is built
1784 for it, using memory allocated to @var{abfd}, and this is then
1785 attached to the @var{abfd}.
1787 Returns a pointer to the build-id structure if a build-id could be
1788 found. If no build-id is found NULL is returned and error code is
1791 static struct bfd_build_id
*
1792 get_build_id (bfd
*abfd
)
1794 struct bfd_build_id
*build_id
;
1795 Elf_Internal_Note inote
;
1796 Elf_External_Note
*enote
;
1803 if (abfd
->build_id
&& abfd
->build_id
->size
> 0)
1804 /* Save some time by using the already computed build-id. */
1805 return (struct bfd_build_id
*) abfd
->build_id
;
1807 sect
= bfd_get_section_by_name (abfd
, ".note.gnu.build-id");
1809 || (sect
->flags
& SEC_HAS_CONTENTS
) == 0)
1811 bfd_set_error (bfd_error_no_debug_section
);
1815 size
= bfd_section_size (sect
);
1816 /* FIXME: Should we support smaller build-id notes ? */
1819 bfd_set_error (bfd_error_invalid_operation
);
1823 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1826 /* FIXME: Paranoia - allow for compressed build-id sections.
1827 Maybe we should complain if this size is different from
1828 the one obtained above... */
1829 size
= bfd_section_size (sect
);
1830 if (size
< sizeof (Elf_External_Note
))
1832 bfd_set_error (bfd_error_invalid_operation
);
1837 enote
= (Elf_External_Note
*) contents
;
1838 inote
.type
= H_GET_32 (abfd
, enote
->type
);
1839 inote
.namesz
= H_GET_32 (abfd
, enote
->namesz
);
1840 inote
.namedata
= enote
->name
;
1841 inote
.descsz
= H_GET_32 (abfd
, enote
->descsz
);
1842 inote
.descdata
= inote
.namedata
+ BFD_ALIGN (inote
.namesz
, 4);
1843 /* FIXME: Should we check for extra notes in this section ? */
1845 if (inote
.descsz
<= 0
1846 || inote
.type
!= NT_GNU_BUILD_ID
1847 || inote
.namesz
!= 4 /* sizeof "GNU" */
1848 || !startswith (inote
.namedata
, "GNU")
1849 || inote
.descsz
> 0x7ffffffe
1850 || size
< (12 + BFD_ALIGN (inote
.namesz
, 4) + inote
.descsz
))
1853 bfd_set_error (bfd_error_invalid_operation
);
1857 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) + inote
.descsz
);
1858 if (build_id
== NULL
)
1864 build_id
->size
= inote
.descsz
;
1865 memcpy (build_id
->data
, inote
.descdata
, inote
.descsz
);
1866 abfd
->build_id
= build_id
;
1872 /* Searches @var{abfd} for a build-id, and then constructs a pathname
1873 from it. The path is computed as .build-id/NN/NN+NN.debug where
1874 NNNN+NN is the build-id value as a hexadecimal string.
1876 Returns the constructed filename or NULL upon error. It is the
1877 caller's responsibility to free the memory used to hold the
1878 filename. If a filename is returned then the @var{build_id_out_p}
1879 parameter (which points to a @code{struct bfd_build_id} pointer) is
1880 set to a pointer to the build_id structure. */
1883 get_build_id_name (bfd
*abfd
, void *build_id_out_p
)
1885 struct bfd_build_id
**build_id_out
= build_id_out_p
;
1886 struct bfd_build_id
*build_id
;
1892 if (abfd
== NULL
|| bfd_get_filename (abfd
) == NULL
|| build_id_out
== NULL
)
1894 bfd_set_error (bfd_error_invalid_operation
);
1898 build_id
= get_build_id (abfd
);
1899 if (build_id
== NULL
)
1902 /* Compute the debug pathname corresponding to the build-id. */
1903 name
= bfd_malloc (strlen (".build-id/") + build_id
->size
* 2 + 2 + strlen (".debug"));
1906 bfd_set_error (bfd_error_no_memory
);
1913 n
+= sprintf (n
, ".build-id/");
1914 n
+= sprintf (n
, "%02x", (unsigned) *d
++); s
--;
1915 n
+= sprintf (n
, "/");
1917 n
+= sprintf (n
, "%02x", (unsigned) *d
++);
1918 n
+= sprintf (n
, ".debug");
1920 *build_id_out
= build_id
;
1924 /* Checks to see if @var{name} is a readable file and if its build-id
1925 matches @var{buildid}.
1927 Returns TRUE if the file exists, is readable, and contains a
1928 build-id which matches the build-id pointed at by @var{build_id_p}
1929 (which is really a @code{struct bfd_build_id **}). */
1932 check_build_id_file (const char *name
, void *buildid_p
)
1934 struct bfd_build_id
*orig_build_id
;
1935 struct bfd_build_id
*build_id
;
1940 BFD_ASSERT (buildid_p
);
1942 file
= bfd_openr (name
, NULL
);
1946 /* If the file is an archive, process all of its elements. */
1947 if (! bfd_check_format (file
, bfd_object
))
1953 build_id
= get_build_id (file
);
1954 if (build_id
== NULL
)
1960 orig_build_id
= *(struct bfd_build_id
**) buildid_p
;
1962 result
= build_id
->size
== orig_build_id
->size
1963 && memcmp (build_id
->data
, orig_build_id
->data
, build_id
->size
) == 0;
1965 (void) bfd_close (file
);
1972 bfd_follow_build_id_debuglink
1975 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
1978 Takes @var{abfd} and searches it for a .note.gnu.build-id section.
1979 If this section is found, it extracts the value of the NT_GNU_BUILD_ID
1980 note, which should be a hexadecimal value @var{NNNN+NN} (for
1981 32+ hex digits). It then searches the filesystem for a file named
1982 @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
1983 including the directory tree rooted at @var{dir}. The filename
1984 of the first matching file to be found is returned. A matching
1985 file should contain a .note.gnu.build-id section with the same
1986 @var{NNNN+NN} note as @var{abfd}, although this check is currently
1989 If @var{dir} is NULL, the search will take place starting at
1990 the current directory.
1992 Returns <<NULL>> on any errors or failure to locate the debug
1993 file, otherwise a pointer to a heap-allocated string
1994 containing the filename. The caller is responsible for
1995 freeing this string.
1999 bfd_follow_build_id_debuglink (bfd
*abfd
, const char *dir
)
2001 struct bfd_build_id
*build_id
;
2003 return find_separate_debug_file (abfd
, dir
, false,
2005 check_build_id_file
, &build_id
);
2013 const char *bfd_set_filename (bfd *abfd, const char *filename);
2016 Set the filename of @var{abfd}, copying the FILENAME parameter to
2017 bfd_alloc'd memory owned by @var{abfd}. Returns a pointer the
2018 newly allocated name, or NULL if the allocation failed.
2022 bfd_set_filename (bfd
*abfd
, const char *filename
)
2024 size_t len
= strlen (filename
) + 1;
2025 char *n
= bfd_alloc (abfd
, len
);
2030 if (abfd
->filename
!= NULL
)
2032 /* PR 29389. If we attempt to rename a file that has been closed due
2033 to caching, then we will not be able to reopen it later on. */
2034 if (abfd
->iostream
== NULL
&& (abfd
->flags
& BFD_CLOSED_BY_CACHE
))
2036 bfd_set_error (bfd_error_invalid_operation
);
2040 /* Similarly if we attempt to close a renamed file because the
2041 cache is now full, we will not be able to reopen it later on. */
2042 if (abfd
->iostream
!= NULL
)
2043 abfd
->cacheable
= 0;
2046 memcpy (n
, filename
, len
);