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
));
86 if (bfd_use_reserved_id
)
88 nbfd
->id
= --bfd_reserved_id_counter
;
89 --bfd_use_reserved_id
;
92 nbfd
->id
= bfd_id_counter
++;
99 nbfd
->memory
= objalloc_create ();
100 if (nbfd
->memory
== NULL
)
102 bfd_set_error (bfd_error_no_memory
);
107 nbfd
->arch_info
= &bfd_default_arch_struct
;
109 if (!bfd_hash_table_init_n (& nbfd
->section_htab
, bfd_section_hash_newfunc
,
110 sizeof (struct section_hash_entry
), 13))
112 objalloc_free ((struct objalloc
*) nbfd
->memory
);
117 nbfd
->archive_plugin_fd
= -1;
122 static const struct bfd_iovec opncls_iovec
;
126 _bfd_new_bfd_contained_in
129 bfd *_bfd_new_bfd_contained_in (bfd *);
132 Allocate a new BFD as a member of archive OBFD.
136 _bfd_new_bfd_contained_in (bfd
*obfd
)
140 /* Nested archives in bims are unsupported. */
141 if ((obfd
->flags
& BFD_IN_MEMORY
) != 0)
143 bfd_set_error (bfd_error_malformed_archive
);
146 nbfd
= _bfd_new_bfd ();
149 nbfd
->xvec
= obfd
->xvec
;
150 nbfd
->iovec
= obfd
->iovec
;
151 if (obfd
->iovec
== &opncls_iovec
)
152 nbfd
->iostream
= obfd
->iostream
;
153 nbfd
->my_archive
= obfd
;
154 nbfd
->direction
= read_direction
;
155 nbfd
->target_defaulted
= obfd
->target_defaulted
;
156 nbfd
->lto_output
= obfd
->lto_output
;
157 nbfd
->no_export
= obfd
->no_export
;
164 _bfd_delete_bfd (bfd
*abfd
)
166 /* Give the target _bfd_free_cached_info a chance to free memory. */
167 if (abfd
->memory
&& abfd
->xvec
)
168 bfd_free_cached_info (abfd
);
170 /* The target _bfd_free_cached_info may not have done anything.. */
173 bfd_hash_table_free (&abfd
->section_htab
);
174 objalloc_free ((struct objalloc
*) abfd
->memory
);
177 free ((char *) bfd_get_filename (abfd
));
179 free (abfd
->arelt_data
);
185 _bfd_free_cached_info
188 bool _bfd_free_cached_info (bfd *);
191 Free objalloc memory.
195 _bfd_free_cached_info (bfd
*abfd
)
199 const char *filename
= bfd_get_filename (abfd
);
202 /* We can't afford to lose the bfd filename when freeing
203 abfd->memory, because that would kill the cache.c scheme
204 of closing and reopening files in order to limit the
205 number of open files. To reopen, you need the filename.
206 And indeed _bfd_compute_and_write_armap calls
207 _bfd_free_cached_info to free up space used by symbols
208 and by check_format_matches. Which we want to continue
209 doing to handle very large archives. Later the archive
210 elements are copied, which might require reopening files.
211 We also want to keep using objalloc memory for the
212 filename since that allows the name to be updated
213 without either leaking memory or implementing some sort
214 of reference counted string for copies of the filename. */
215 size_t len
= strlen (filename
) + 1;
216 char *copy
= bfd_malloc (len
);
219 memcpy (copy
, filename
, len
);
220 abfd
->filename
= copy
;
222 bfd_hash_table_free (&abfd
->section_htab
);
223 objalloc_free ((struct objalloc
*) abfd
->memory
);
225 abfd
->sections
= NULL
;
226 abfd
->section_last
= NULL
;
227 abfd
->outsymbols
= NULL
;
228 abfd
->tdata
.any
= NULL
;
229 abfd
->usrdata
= NULL
;
241 bfd *bfd_fopen (const char *filename, const char *target,
242 const char *mode, int fd);
245 Open the file @var{filename} with the target @var{target}.
246 Return a pointer to the created BFD. If @var{fd} is not -1,
247 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
248 is used. @var{mode} is passed directly to <<fopen>> or
251 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
254 The new BFD is marked as cacheable iff @var{fd} is -1.
256 If <<NULL>> is returned then an error has occured. Possible errors
257 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
258 <<system_call>> error.
260 On error, @var{fd} is always closed.
262 A copy of the @var{filename} argument is stored in the newly created
263 BFD. It can be accessed via the bfd_get_filename() macro.
267 bfd_fopen (const char *filename
, const char *target
, const char *mode
, int fd
)
270 const bfd_target
*target_vec
;
272 nbfd
= _bfd_new_bfd ();
280 target_vec
= bfd_find_target (target
, nbfd
);
281 if (target_vec
== NULL
)
285 _bfd_delete_bfd (nbfd
);
291 nbfd
->iostream
= fdopen (fd
, mode
);
294 nbfd
->iostream
= _bfd_real_fopen (filename
, mode
);
295 if (nbfd
->iostream
== NULL
)
297 bfd_set_error (bfd_error_system_call
);
300 _bfd_delete_bfd (nbfd
);
304 /* OK, put everything where it belongs. */
306 /* PR 11983: Do not cache the original filename, but
307 rather make a copy - the original might go away. */
308 if (!bfd_set_filename (nbfd
, filename
))
310 fclose (nbfd
->iostream
);
311 _bfd_delete_bfd (nbfd
);
315 /* Figure out whether the user is opening the file for reading,
316 writing, or both, by looking at the MODE argument. */
317 if ((mode
[0] == 'r' || mode
[0] == 'w' || mode
[0] == 'a')
319 nbfd
->direction
= both_direction
;
320 else if (mode
[0] == 'r')
321 nbfd
->direction
= read_direction
;
323 nbfd
->direction
= write_direction
;
325 if (!bfd_cache_init (nbfd
))
327 fclose (nbfd
->iostream
);
328 _bfd_delete_bfd (nbfd
);
331 nbfd
->opened_once
= true;
333 /* If we opened the file by name, mark it cacheable; we can close it
334 and reopen it later. However, if a file descriptor was provided,
335 then it may have been opened with special flags that make it
336 unsafe to close and reopen the file. */
338 (void) bfd_set_cacheable (nbfd
, true);
348 bfd *bfd_openr (const char *filename, const char *target);
351 Open the file @var{filename} (using <<fopen>>) with the target
352 @var{target}. Return a pointer to the created BFD.
354 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
357 If <<NULL>> is returned then an error has occured. Possible errors
358 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
359 <<system_call>> error.
361 A copy of the @var{filename} argument is stored in the newly created
362 BFD. It can be accessed via the bfd_get_filename() macro.
366 bfd_openr (const char *filename
, const char *target
)
368 return bfd_fopen (filename
, target
, FOPEN_RB
, -1);
371 /* Don't try to `optimize' this function:
373 o - We lock using stack space so that interrupting the locking
374 won't cause a storage leak.
375 o - We open the file stream last, since we don't want to have to
376 close it if anything goes wrong. Closing the stream means closing
377 the file descriptor too, even though we didn't open it. */
383 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
386 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
387 <<fopen>>. It opens a BFD on a file already described by the
390 When the file is later <<bfd_close>>d, the file descriptor will
391 be closed. If the caller desires that this file descriptor be
392 cached by BFD (opened as needed, closed as needed to free
393 descriptors for other opens), with the supplied @var{fd} used as
394 an initial file descriptor (but subject to closure at any time),
395 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
396 is to assume no caching; the file descriptor will remain open
397 until <<bfd_close>>, and will not be affected by BFD operations
400 Possible errors are <<bfd_error_no_memory>>,
401 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
403 On error, @var{fd} is closed.
405 A copy of the @var{filename} argument is stored in the newly created
406 BFD. It can be accessed via the bfd_get_filename() macro.
410 bfd_fdopenr (const char *filename
, const char *target
, int fd
)
413 #if defined(HAVE_FCNTL) && defined(F_GETFL)
417 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
418 mode
= FOPEN_RUB
; /* Assume full access. */
420 fdflags
= fcntl (fd
, F_GETFL
, NULL
);
427 bfd_set_error (bfd_error_system_call
);
431 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
432 switch (fdflags
& (O_ACCMODE
))
434 case O_RDONLY
: mode
= FOPEN_RB
; break;
435 case O_WRONLY
: mode
= FOPEN_RUB
; break;
436 case O_RDWR
: mode
= FOPEN_RUB
; break;
441 return bfd_fopen (filename
, target
, mode
, fd
);
449 bfd *bfd_fdopenw (const char *filename, const char *target, int fd);
452 <<bfd_fdopenw>> is exactly like <<bfd_fdopenr>> with the exception that
453 the resulting BFD is suitable for output.
457 bfd_fdopenw (const char *filename
, const char *target
, int fd
)
459 bfd
*out
= bfd_fdopenr (filename
, target
, fd
);
463 if (!bfd_write_p (out
))
466 _bfd_delete_bfd (out
);
468 bfd_set_error (bfd_error_invalid_operation
);
471 out
->direction
= write_direction
;
482 bfd *bfd_openstreamr (const char * filename, const char * target,
486 Open a BFD for read access on an existing stdio stream. When
487 the BFD is passed to <<bfd_close>>, the stream will be closed.
489 A copy of the @var{filename} argument is stored in the newly created
490 BFD. It can be accessed via the bfd_get_filename() macro.
494 bfd_openstreamr (const char *filename
, const char *target
, void *streamarg
)
496 FILE *stream
= (FILE *) streamarg
;
498 const bfd_target
*target_vec
;
500 nbfd
= _bfd_new_bfd ();
504 target_vec
= bfd_find_target (target
, nbfd
);
505 if (target_vec
== NULL
)
507 _bfd_delete_bfd (nbfd
);
511 nbfd
->iostream
= stream
;
512 /* PR 11983: Do not cache the original filename, but
513 rather make a copy - the original might go away. */
514 if (!bfd_set_filename (nbfd
, filename
))
516 _bfd_delete_bfd (nbfd
);
519 nbfd
->direction
= read_direction
;
521 if (! bfd_cache_init (nbfd
))
523 _bfd_delete_bfd (nbfd
);
535 bfd *bfd_openr_iovec (const char *filename, const char *target,
536 void *(*open_func) (struct bfd *nbfd,
539 file_ptr (*pread_func) (struct bfd *nbfd,
544 int (*close_func) (struct bfd *nbfd,
546 int (*stat_func) (struct bfd *abfd,
551 Create and return a BFD backed by a read-only @var{stream}.
552 The @var{stream} is created using @var{open_func}, accessed using
553 @var{pread_func} and destroyed using @var{close_func}.
555 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
558 Calls @var{open_func} (which can call <<bfd_zalloc>> and
559 <<bfd_get_filename>>) to obtain the read-only stream backing
560 the BFD. @var{open_func} either succeeds returning the
561 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
562 (setting <<bfd_error>>).
564 Calls @var{pread_func} to request @var{nbytes} of data from
565 @var{stream} starting at @var{offset} (e.g., via a call to
566 <<bfd_read>>). @var{pread_func} either succeeds returning the
567 number of bytes read (which can be less than @var{nbytes} when
568 end-of-file), or fails returning -1 (setting <<bfd_error>>).
570 Calls @var{close_func} when the BFD is later closed using
571 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
572 fails returning -1 (setting <<bfd_error>>).
574 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
575 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
576 on success, or returns -1 on failure (setting <<bfd_error>>).
578 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
579 occurred. Possible errors are <<bfd_error_no_memory>>,
580 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
582 A copy of the @var{filename} argument is stored in the newly created
583 BFD. It can be accessed via the bfd_get_filename() macro.
589 file_ptr (*pread
) (struct bfd
*abfd
, void *stream
, void *buf
,
590 file_ptr nbytes
, file_ptr offset
);
591 int (*close
) (struct bfd
*abfd
, void *stream
);
592 int (*stat
) (struct bfd
*abfd
, void *stream
, struct stat
*sb
);
597 opncls_btell (struct bfd
*abfd
)
599 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
604 opncls_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
606 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
609 case SEEK_SET
: vec
->where
= offset
; break;
610 case SEEK_CUR
: vec
->where
+= offset
; break;
611 case SEEK_END
: return -1;
617 opncls_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
619 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
620 file_ptr nread
= (vec
->pread
) (abfd
, vec
->stream
, buf
, nbytes
, vec
->where
);
629 opncls_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
630 const void *where ATTRIBUTE_UNUSED
,
631 file_ptr nbytes ATTRIBUTE_UNUSED
)
637 opncls_bclose (struct bfd
*abfd
)
639 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
640 /* Since the VEC's memory is bound to the bfd deleting the bfd will
644 if (vec
->close
!= NULL
)
645 status
= (vec
->close
) (abfd
, vec
->stream
);
646 abfd
->iostream
= NULL
;
651 opncls_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
657 opncls_bstat (struct bfd
*abfd
, struct stat
*sb
)
659 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
661 memset (sb
, 0, sizeof (*sb
));
662 if (vec
->stat
== NULL
)
665 return (vec
->stat
) (abfd
, vec
->stream
, sb
);
669 opncls_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
670 void *addr ATTRIBUTE_UNUSED
,
671 bfd_size_type len ATTRIBUTE_UNUSED
,
672 int prot ATTRIBUTE_UNUSED
,
673 int flags ATTRIBUTE_UNUSED
,
674 file_ptr offset ATTRIBUTE_UNUSED
,
675 void **map_addr ATTRIBUTE_UNUSED
,
676 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
681 static const struct bfd_iovec opncls_iovec
=
683 &opncls_bread
, &opncls_bwrite
, &opncls_btell
, &opncls_bseek
,
684 &opncls_bclose
, &opncls_bflush
, &opncls_bstat
, &opncls_bmmap
688 bfd_openr_iovec (const char *filename
, const char *target
,
689 void *(*open_p
) (struct bfd
*, void *),
691 file_ptr (*pread_p
) (struct bfd
*, void *, void *,
693 int (*close_p
) (struct bfd
*, void *),
694 int (*stat_p
) (struct bfd
*, void *, struct stat
*))
697 const bfd_target
*target_vec
;
701 nbfd
= _bfd_new_bfd ();
705 target_vec
= bfd_find_target (target
, nbfd
);
706 if (target_vec
== NULL
)
708 _bfd_delete_bfd (nbfd
);
712 /* PR 11983: Do not cache the original filename, but
713 rather make a copy - the original might go away. */
714 if (!bfd_set_filename (nbfd
, filename
))
716 _bfd_delete_bfd (nbfd
);
719 nbfd
->direction
= read_direction
;
721 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
722 stream
= (*open_p
) (nbfd
, open_closure
);
725 _bfd_delete_bfd (nbfd
);
729 vec
= (struct opncls
*) bfd_zalloc (nbfd
, sizeof (struct opncls
));
730 vec
->stream
= stream
;
731 vec
->pread
= pread_p
;
732 vec
->close
= close_p
;
735 nbfd
->iovec
= &opncls_iovec
;
736 nbfd
->iostream
= vec
;
741 /* bfd_openw -- open for writing.
742 Returns a pointer to a freshly-allocated BFD on success, or NULL.
744 See comment by bfd_fdopenr before you try to modify this function. */
751 bfd *bfd_openw (const char *filename, const char *target);
754 Create a BFD, associated with file @var{filename}, using the
755 file format @var{target}, and return a pointer to it.
757 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
758 <<bfd_error_invalid_target>>.
760 A copy of the @var{filename} argument is stored in the newly created
761 BFD. It can be accessed via the bfd_get_filename() macro.
765 bfd_openw (const char *filename
, const char *target
)
768 const bfd_target
*target_vec
;
770 /* nbfd has to point to head of malloc'ed block so that bfd_close may
771 reclaim it correctly. */
772 nbfd
= _bfd_new_bfd ();
776 target_vec
= bfd_find_target (target
, nbfd
);
777 if (target_vec
== NULL
)
779 _bfd_delete_bfd (nbfd
);
783 /* PR 11983: Do not cache the original filename, but
784 rather make a copy - the original might go away. */
785 if (!bfd_set_filename (nbfd
, filename
))
787 _bfd_delete_bfd (nbfd
);
790 nbfd
->direction
= write_direction
;
792 if (bfd_open_file (nbfd
) == NULL
)
794 /* File not writeable, etc. */
795 bfd_set_error (bfd_error_system_call
);
796 _bfd_delete_bfd (nbfd
);
805 bfd_elf_bfd_from_remote_memory
808 bfd *bfd_elf_bfd_from_remote_memory
809 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep,
810 int (*target_read_memory)
811 (bfd_vma vma, bfd_byte *myaddr, bfd_size_type len));
814 Create a new BFD as if by bfd_openr. Rather than opening a
815 file, reconstruct an ELF file by reading the segments out of
816 remote memory based on the ELF file header at EHDR_VMA and the
817 ELF program headers it points to. If non-zero, SIZE is the
818 known extent of the object. If not null, *LOADBASEP is filled
819 in with the difference between the VMAs from which the
820 segments were read, and the VMAs the file headers (and hence
821 BFD's idea of each section's VMA) put them at.
823 The function TARGET_READ_MEMORY is called to copy LEN bytes
824 from the remote memory at target address VMA into the local
825 buffer at MYADDR; it should return zero on success or an
826 errno code on failure. TEMPL must be a BFD for an ELF
827 target with the word size and byte order found in the remote
832 bfd_elf_bfd_from_remote_memory
837 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
839 if (bfd_get_flavour (templ
) != bfd_target_elf_flavour
)
841 bfd_set_error (bfd_error_invalid_operation
);
844 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
845 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
849 _maybe_make_executable (bfd
* abfd
)
851 /* If the file was open for writing and is now executable,
853 if (abfd
->direction
== write_direction
854 && (abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
858 if (stat (bfd_get_filename (abfd
), &buf
) == 0
859 /* Do not attempt to change non-regular files. This is
860 here especially for configure scripts and kernel builds
861 which run tests with "ld [...] -o /dev/null". */
862 && S_ISREG(buf
.st_mode
))
864 unsigned int mask
= umask (0);
867 chmod (bfd_get_filename (abfd
),
869 & (buf
.st_mode
| ((S_IXUSR
| S_IXGRP
| S_IXOTH
) &~ mask
))));
879 bool bfd_close (bfd *abfd);
882 Close a BFD. If the BFD was open for writing, then pending
883 operations are completed and the file written out and closed.
884 If the created file is executable, then <<chmod>> is called
887 All memory attached to the BFD is released.
889 The file descriptor associated with the BFD is closed (even
890 if it was passed in to BFD by <<bfd_fdopenr>>).
892 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
896 bfd_close (bfd
*abfd
)
898 bool ret
= (!bfd_write_p (abfd
)
899 || BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)));
901 return bfd_close_all_done (abfd
) && ret
;
909 bool bfd_close_all_done (bfd *);
912 Close a BFD. Differs from <<bfd_close>> since it does not
913 complete any pending operations. This routine would be used
914 if the application had just used BFD for swapping and didn't
915 want to use any of the writing code.
917 If the created file is executable, then <<chmod>> is called
920 All memory attached to the BFD is released.
922 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
926 bfd_close_all_done (bfd
*abfd
)
928 bool ret
= BFD_SEND (abfd
, _close_and_cleanup
, (abfd
));
930 if (abfd
->iovec
!= NULL
)
931 ret
&= abfd
->iovec
->bclose (abfd
) == 0;
934 _maybe_make_executable (abfd
);
936 _bfd_delete_bfd (abfd
);
937 _bfd_clear_error_data ();
947 bfd *bfd_create (const char *filename, bfd *templ);
950 Create a new BFD in the manner of <<bfd_openw>>, but without
951 opening a file. The new BFD takes the target from the target
952 used by @var{templ}. The format is always set to <<bfd_object>>.
954 A copy of the @var{filename} argument is stored in the newly created
955 BFD. It can be accessed via the bfd_get_filename() macro.
959 bfd_create (const char *filename
, bfd
*templ
)
963 nbfd
= _bfd_new_bfd ();
966 /* PR 11983: Do not cache the original filename, but
967 rather make a copy - the original might go away. */
968 if (!bfd_set_filename (nbfd
, filename
))
970 _bfd_delete_bfd (nbfd
);
974 nbfd
->xvec
= templ
->xvec
;
975 nbfd
->direction
= no_direction
;
976 bfd_set_format (nbfd
, bfd_object
);
986 bool bfd_make_writable (bfd *abfd);
989 Takes a BFD as created by <<bfd_create>> and converts it
990 into one like as returned by <<bfd_openw>>. It does this
991 by converting the BFD to BFD_IN_MEMORY. It's assumed that
992 you will call <<bfd_make_readable>> on this bfd later.
994 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
998 bfd_make_writable (bfd
*abfd
)
1000 struct bfd_in_memory
*bim
;
1002 if (abfd
->direction
!= no_direction
)
1004 bfd_set_error (bfd_error_invalid_operation
);
1008 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
1010 return false; /* bfd_error already set. */
1011 abfd
->iostream
= bim
;
1012 /* bfd_write will grow these as needed. */
1016 abfd
->flags
|= BFD_IN_MEMORY
;
1017 abfd
->iovec
= &_bfd_memory_iovec
;
1019 abfd
->direction
= write_direction
;
1030 bool bfd_make_readable (bfd *abfd);
1033 Takes a BFD as created by <<bfd_create>> and
1034 <<bfd_make_writable>> and converts it into one like as
1035 returned by <<bfd_openr>>. It does this by writing the
1036 contents out to the memory buffer, then reversing the
1039 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
1042 bfd_make_readable (bfd
*abfd
)
1044 if (abfd
->direction
!= write_direction
|| !(abfd
->flags
& BFD_IN_MEMORY
))
1046 bfd_set_error (bfd_error_invalid_operation
);
1050 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
1053 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
1056 abfd
->arch_info
= &bfd_default_arch_struct
;
1059 abfd
->format
= bfd_unknown
;
1060 abfd
->my_archive
= NULL
;
1062 abfd
->opened_once
= false;
1063 abfd
->output_has_begun
= false;
1064 abfd
->section_count
= 0;
1065 abfd
->usrdata
= NULL
;
1066 abfd
->cacheable
= false;
1067 abfd
->flags
|= BFD_IN_MEMORY
;
1068 abfd
->mtime_set
= false;
1070 abfd
->target_defaulted
= true;
1071 abfd
->direction
= read_direction
;
1074 abfd
->outsymbols
= 0;
1075 abfd
->tdata
.any
= 0;
1078 bfd_section_list_clear (abfd
);
1079 bfd_check_format (abfd
, bfd_object
);
1085 GNU Extension: separate debug-info files
1087 The idea here is that a special section called .gnu_debuglink might be
1088 embedded in a binary file, which indicates that some *other* file
1089 contains the real debugging information. This special section contains a
1090 filename and CRC32 checksum, which we read and resolve to another file,
1093 This facilitates "optional" provision of debugging information, without
1094 having to provide two complete copies of every binary object (with and
1095 without debug symbols). */
1097 #define GNU_DEBUGLINK ".gnu_debuglink"
1098 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1102 bfd_calc_gnu_debuglink_crc32
1105 uint32_t bfd_calc_gnu_debuglink_crc32
1106 (uint32_t crc, const bfd_byte *buf, bfd_size_type len);
1109 Computes a CRC value as used in the .gnu_debuglink section.
1110 Advances the previously computed @var{crc} value by computing
1111 and adding in the crc32 for @var{len} bytes of @var{buf}.
1113 Return the updated CRC32 value.
1117 bfd_calc_gnu_debuglink_crc32 (uint32_t crc
,
1118 const bfd_byte
*buf
,
1121 static const uint32_t crc32_table
[256] =
1123 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1124 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1125 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1126 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1127 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1128 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1129 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1130 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1131 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1132 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1133 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1134 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1135 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1136 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1137 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1138 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1139 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1140 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1141 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1142 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1143 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1144 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1145 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1146 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1147 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1148 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1149 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1150 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1151 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1152 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1153 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1154 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1155 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1156 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1157 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1158 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1159 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1160 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1161 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1162 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1163 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1164 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1165 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1166 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1167 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1168 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1169 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1170 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1171 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1172 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1173 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1176 const bfd_byte
*end
;
1178 crc
= ~crc
& 0xffffffff;
1179 for (end
= buf
+ len
; buf
< end
; ++ buf
)
1180 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
1181 return ~crc
& 0xffffffff;
1185 /* Extracts the filename and CRC32 value for any separate debug
1186 information file associated with @var{abfd}.
1188 The @var{crc32_out} parameter is an untyped pointer because
1189 this routine is used as a @code{get_func_type} function, but it
1190 is expected to be a uint32_t pointer.
1192 Returns the filename of the associated debug information file,
1193 or NULL if there is no such file. If the filename was found
1194 then the contents of @var{crc32_out} are updated to hold the
1195 corresponding CRC32 value for the file.
1197 The returned filename is allocated with @code{malloc}; freeing
1198 it is the responsibility of the caller. */
1201 bfd_get_debug_link_info_1 (bfd
*abfd
, void *crc32_out
)
1204 uint32_t *crc32
= crc32_out
;
1206 unsigned int crc_offset
;
1211 BFD_ASSERT (crc32_out
);
1213 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1215 if (sect
== NULL
|| (sect
->flags
& SEC_HAS_CONTENTS
) == 0)
1218 size
= bfd_section_size (sect
);
1220 /* PR 22794: Make sure that the section has a reasonable size. */
1224 if (!bfd_malloc_and_get_section (abfd
, sect
, &contents
))
1227 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1228 name
= (char *) contents
;
1229 /* PR 17597: Avoid reading off the end of the buffer. */
1230 crc_offset
= strnlen (name
, size
) + 1;
1231 crc_offset
= (crc_offset
+ 3) & ~3;
1232 if (crc_offset
+ 4 > size
)
1238 *crc32
= bfd_get_32 (abfd
, contents
+ crc_offset
);
1245 bfd_get_debug_link_info
1248 char *bfd_get_debug_link_info (bfd *abfd, uint32_t *crc32_out);
1251 Extracts the filename and CRC32 value for any separate debug
1252 information file associated with @var{abfd}.
1254 Returns the filename of the associated debug information file,
1255 or NULL if there is no such file. If the filename was found
1256 then the contents of @var{crc32_out} are updated to hold the
1257 corresponding CRC32 value for the file.
1259 The returned filename is allocated with @code{malloc}; freeing
1260 it is the responsibility of the caller.
1264 bfd_get_debug_link_info (bfd
*abfd
, uint32_t *crc32_out
)
1266 return bfd_get_debug_link_info_1 (abfd
, crc32_out
);
1271 bfd_get_alt_debug_link_info
1274 char *bfd_get_alt_debug_link_info (bfd * abfd,
1275 bfd_size_type *buildid_len,
1276 bfd_byte **buildid_out);
1279 Fetch the filename and BuildID value for any alternate debuginfo
1280 associated with @var{abfd}. Return NULL if no such info found,
1281 otherwise return filename and update @var{buildid_len} and
1282 @var{buildid_out}. The returned filename and build_id are
1283 allocated with @code{malloc}; freeing them is the responsibility
1288 bfd_get_alt_debug_link_info (bfd
* abfd
, bfd_size_type
*buildid_len
,
1289 bfd_byte
**buildid_out
)
1293 unsigned int buildid_offset
;
1298 BFD_ASSERT (buildid_len
);
1299 BFD_ASSERT (buildid_out
);
1301 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGALTLINK
);
1303 if (sect
== NULL
|| (sect
->flags
& SEC_HAS_CONTENTS
) == 0)
1306 size
= bfd_section_size (sect
);
1310 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1313 /* BuildID value is stored after the filename. */
1314 name
= (char *) contents
;
1315 buildid_offset
= strnlen (name
, size
) + 1;
1316 if (buildid_offset
>= bfd_section_size (sect
))
1319 *buildid_len
= size
- buildid_offset
;
1320 *buildid_out
= bfd_malloc (*buildid_len
);
1321 memcpy (*buildid_out
, contents
+ buildid_offset
, *buildid_len
);
1326 /* Checks to see if @var{name} is a file and if its contents match
1327 @var{crc32}, which is a pointer to a @code{uint32_t}
1330 The @var{crc32_p} parameter is an untyped pointer because this
1331 routine is used as a @code{check_func_type} function. */
1334 separate_debug_file_exists (const char *name
, void *crc32_p
)
1336 unsigned char buffer
[8 * 1024];
1337 uint32_t file_crc
= 0;
1339 bfd_size_type count
;
1343 BFD_ASSERT (crc32_p
);
1345 crc
= *(uint32_t *) crc32_p
;
1347 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1351 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
1352 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1356 return crc
== file_crc
;
1359 /* Checks to see if @var{name} is a file. */
1362 separate_alt_debug_file_exists (const char *name
, void *unused ATTRIBUTE_UNUSED
)
1368 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1377 /* Searches for a debug information file corresponding to @var{abfd}.
1379 The name of the separate debug info file is returned by the
1380 @var{get} function. This function scans various fixed locations
1381 in the filesystem, including the file tree rooted at @var{dir}.
1382 If the @var{include_dirs} parameter is true then the directory
1383 components of @var{abfd}'s filename will be included in the
1386 @var{data} is passed unmodified to the @var{get} and @var{check}
1387 functions. It is generally used to implement build-id-like
1388 matching in the callback functions.
1390 Returns the filename of the first file to be found which
1391 receives a TRUE result from the @var{check} function.
1392 Returns NULL if no valid file could be found. */
1394 typedef char * (*get_func_type
) (bfd
*, void *);
1395 typedef bool (*check_func_type
) (const char *, void *);
1398 find_separate_debug_file (bfd
*abfd
,
1399 const char *debug_file_directory
,
1401 get_func_type get_func
,
1402 check_func_type check_func
,
1410 size_t canon_dirlen
;
1413 if (debug_file_directory
== NULL
)
1414 debug_file_directory
= ".";
1416 /* BFD may have been opened from a stream. */
1417 if (bfd_get_filename (abfd
) == NULL
)
1419 bfd_set_error (bfd_error_invalid_operation
);
1423 base
= get_func (abfd
, func_data
);
1428 if (base
[0] == '\0')
1431 bfd_set_error (bfd_error_no_debug_section
);
1437 const char *fname
= bfd_get_filename (abfd
);
1438 for (dirlen
= strlen (fname
); dirlen
> 0; dirlen
--)
1439 if (IS_DIR_SEPARATOR (fname
[dirlen
- 1]))
1442 dir
= (char *) bfd_malloc (dirlen
+ 1);
1448 memcpy (dir
, fname
, dirlen
);
1453 dir
= (char *) bfd_malloc (1);
1458 /* Compute the canonical name of the bfd object with all symbolic links
1459 resolved, for use in the global debugfile directory. */
1460 canon_dir
= lrealpath (bfd_get_filename (abfd
));
1461 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
1462 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
1464 canon_dir
[canon_dirlen
] = '\0';
1466 #ifndef EXTRA_DEBUG_ROOT1
1467 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1469 #ifndef EXTRA_DEBUG_ROOT2
1470 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1473 debugfile
= (char *)
1474 bfd_malloc (strlen (debug_file_directory
) + 1
1475 + (canon_dirlen
> dirlen
? canon_dirlen
: dirlen
)
1476 + strlen (".debug/")
1477 #ifdef EXTRA_DEBUG_ROOT1
1478 + strlen (EXTRA_DEBUG_ROOT1
)
1480 #ifdef EXTRA_DEBUG_ROOT2
1481 + strlen (EXTRA_DEBUG_ROOT2
)
1485 if (debugfile
== NULL
)
1486 goto found
; /* Actually this returns NULL. */
1488 /* First try in the same directory as the original file.
1490 FIXME: Strictly speaking if we are using the build-id method,
1491 (ie include_dirs == FALSE) then we should only check absolute
1492 paths, not relative ones like this one (and the next one).
1493 The check is left in however as this allows the binutils
1494 testsuite to exercise this feature without having to install
1495 a file into the root filesystem. (See binutils/testsuite/
1496 binutils-all/objdump.exp for the test). */
1497 sprintf (debugfile
, "%s%s", dir
, base
);
1498 if (check_func (debugfile
, func_data
))
1501 /* Then try in a subdirectory called .debug. */
1502 sprintf (debugfile
, "%s.debug/%s", dir
, base
);
1503 if (check_func (debugfile
, func_data
))
1506 #ifdef EXTRA_DEBUG_ROOT1
1507 /* Try the first extra debug file root. */
1508 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT1
,
1509 include_dirs
? canon_dir
: "/", base
);
1510 if (check_func (debugfile
, func_data
))
1514 #ifdef EXTRA_DEBUG_ROOT2
1515 /* Try the second extra debug file root. */
1516 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT2
,
1517 include_dirs
? canon_dir
: "/", base
);
1518 if (check_func (debugfile
, func_data
))
1522 /* Then try in the global debugfile directory. */
1523 strcpy (debugfile
, debug_file_directory
);
1524 dirlen
= strlen (debug_file_directory
) - 1;
1528 && debug_file_directory
[dirlen
] != '/'
1529 && canon_dir
[0] != '/')
1530 strcat (debugfile
, "/");
1531 strcat (debugfile
, canon_dir
);
1535 if (dirlen
> 0 && debug_file_directory
[dirlen
] != '/')
1536 strcat (debugfile
, "/");
1538 strcat (debugfile
, base
);
1540 if (check_func (debugfile
, func_data
))
1543 /* Failed to find the file. */
1556 bfd_follow_gnu_debuglink
1559 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1562 Takes a BFD and searches it for a .gnu_debuglink section. If this
1563 section is found, it examines the section for the name and checksum
1564 of a '.debug' file containing auxiliary debugging information. It
1565 then searches the filesystem for this .debug file in some standard
1566 locations, including the directory tree rooted at @var{dir}, and if
1567 found returns the full filename.
1569 If @var{dir} is NULL, the search will take place starting at
1570 the current directory.
1572 Returns <<NULL>> on any errors or failure to locate the .debug
1573 file, otherwise a pointer to a heap-allocated string
1574 containing the filename. The caller is responsible for
1575 freeing this string.
1579 bfd_follow_gnu_debuglink (bfd
*abfd
, const char *dir
)
1583 return find_separate_debug_file (abfd
, dir
, true,
1584 bfd_get_debug_link_info_1
,
1585 separate_debug_file_exists
, &crc32
);
1588 /* Helper for bfd_follow_gnu_debugaltlink. It just returns the name
1589 of the separate debug file. */
1592 get_alt_debug_link_info_shim (bfd
* abfd
, void *unused ATTRIBUTE_UNUSED
)
1595 bfd_byte
*buildid
= NULL
;
1596 char *result
= bfd_get_alt_debug_link_info (abfd
, &len
, &buildid
);
1605 bfd_follow_gnu_debugaltlink
1608 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1611 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1612 section is found, it examines the section for the name of a file
1613 containing auxiliary debugging information. It then searches the
1614 filesystem for this file in a set of standard locations, including
1615 the directory tree rooted at @var{dir}, and if found returns the
1618 If @var{dir} is NULL, the search will take place starting at
1619 the current directory.
1621 Returns <<NULL>> on any errors or failure to locate the debug
1622 file, otherwise a pointer to a heap-allocated string
1623 containing the filename. The caller is responsible for
1624 freeing this string.
1628 bfd_follow_gnu_debugaltlink (bfd
*abfd
, const char *dir
)
1630 return find_separate_debug_file (abfd
, dir
, true,
1631 get_alt_debug_link_info_shim
,
1632 separate_alt_debug_file_exists
,
1638 bfd_create_gnu_debuglink_section
1641 struct bfd_section *bfd_create_gnu_debuglink_section
1642 (bfd *abfd, const char *filename);
1645 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The
1646 section is sized to be big enough to contain a link to the specified
1649 A pointer to the new section is returned if all is ok. Otherwise
1650 <<NULL>> is returned and bfd_error is set.
1654 bfd_create_gnu_debuglink_section (bfd
*abfd
, const char *filename
)
1657 bfd_size_type debuglink_size
;
1660 if (abfd
== NULL
|| filename
== NULL
)
1662 bfd_set_error (bfd_error_invalid_operation
);
1666 /* Strip off any path components in filename. */
1667 filename
= lbasename (filename
);
1669 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1672 /* Section already exists. */
1673 bfd_set_error (bfd_error_invalid_operation
);
1677 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DEBUGGING
;
1678 sect
= bfd_make_section_with_flags (abfd
, GNU_DEBUGLINK
, flags
);
1682 /* Compute the size of the section. Allow for the CRC after the filename,
1683 and padding so that it will start on a 4-byte boundary. */
1684 debuglink_size
= strlen (filename
) + 1;
1685 debuglink_size
+= 3;
1686 debuglink_size
&= ~3;
1687 debuglink_size
+= 4;
1689 if (!bfd_set_section_size (sect
, debuglink_size
))
1690 /* XXX Should we delete the section from the bfd ? */
1693 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1694 Note - despite the name of the function being called, we are
1695 setting an alignment power, not a byte alignment value. */
1696 bfd_set_section_alignment (sect
, 2);
1704 bfd_fill_in_gnu_debuglink_section
1707 bool bfd_fill_in_gnu_debuglink_section
1708 (bfd *abfd, struct bfd_section *sect, const char *filename);
1711 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1712 and fills in the contents of the section to contain a link to the
1713 specified @var{filename}. The filename should be absolute or
1714 relative to the current directory.
1716 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1717 and bfd_error is set.
1721 bfd_fill_in_gnu_debuglink_section (bfd
*abfd
,
1722 struct bfd_section
*sect
,
1723 const char *filename
)
1725 bfd_size_type debuglink_size
;
1728 bfd_size_type crc_offset
;
1730 unsigned char buffer
[8 * 1024];
1734 if (abfd
== NULL
|| sect
== NULL
|| filename
== NULL
)
1736 bfd_set_error (bfd_error_invalid_operation
);
1740 /* Open the linked file so that we can compute a CRC. */
1741 handle
= _bfd_real_fopen (filename
, FOPEN_RB
);
1744 bfd_set_error (bfd_error_system_call
);
1749 while ((count
= fread (buffer
, 1, sizeof buffer
, handle
)) > 0)
1750 crc32
= bfd_calc_gnu_debuglink_crc32 (crc32
, buffer
, count
);
1753 /* Strip off any path components in filename,
1754 now that we no longer need them. */
1755 filename
= lbasename (filename
);
1757 filelen
= strlen (filename
);
1758 debuglink_size
= filelen
+ 1;
1759 debuglink_size
+= 3;
1760 debuglink_size
&= ~3;
1761 debuglink_size
+= 4;
1763 contents
= (char *) bfd_malloc (debuglink_size
);
1764 if (contents
== NULL
)
1766 /* XXX Should we delete the section from the bfd ? */
1770 crc_offset
= debuglink_size
- 4;
1771 memcpy (contents
, filename
, filelen
);
1772 memset (contents
+ filelen
, 0, crc_offset
- filelen
);
1774 bfd_put_32 (abfd
, crc32
, contents
+ crc_offset
);
1776 if (! bfd_set_section_contents (abfd
, sect
, contents
, 0, debuglink_size
))
1778 /* XXX Should we delete the section from the bfd ? */
1786 /* Finds the build-id associated with @var{abfd}. If the build-id is
1787 extracted from the note section then a build-id structure is built
1788 for it, using memory allocated to @var{abfd}, and this is then
1789 attached to the @var{abfd}.
1791 Returns a pointer to the build-id structure if a build-id could be
1792 found. If no build-id is found NULL is returned and error code is
1795 static struct bfd_build_id
*
1796 get_build_id (bfd
*abfd
)
1798 struct bfd_build_id
*build_id
;
1799 Elf_Internal_Note inote
;
1800 Elf_External_Note
*enote
;
1807 if (abfd
->build_id
&& abfd
->build_id
->size
> 0)
1808 /* Save some time by using the already computed build-id. */
1809 return (struct bfd_build_id
*) abfd
->build_id
;
1811 sect
= bfd_get_section_by_name (abfd
, ".note.gnu.build-id");
1813 || (sect
->flags
& SEC_HAS_CONTENTS
) == 0)
1815 bfd_set_error (bfd_error_no_debug_section
);
1819 size
= bfd_section_size (sect
);
1820 /* FIXME: Should we support smaller build-id notes ? */
1823 bfd_set_error (bfd_error_invalid_operation
);
1827 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1830 /* FIXME: Paranoia - allow for compressed build-id sections.
1831 Maybe we should complain if this size is different from
1832 the one obtained above... */
1833 size
= bfd_section_size (sect
);
1834 if (size
< sizeof (Elf_External_Note
))
1836 bfd_set_error (bfd_error_invalid_operation
);
1841 enote
= (Elf_External_Note
*) contents
;
1842 inote
.type
= H_GET_32 (abfd
, enote
->type
);
1843 inote
.namesz
= H_GET_32 (abfd
, enote
->namesz
);
1844 inote
.namedata
= enote
->name
;
1845 inote
.descsz
= H_GET_32 (abfd
, enote
->descsz
);
1846 inote
.descdata
= inote
.namedata
+ BFD_ALIGN (inote
.namesz
, 4);
1847 /* FIXME: Should we check for extra notes in this section ? */
1849 if (inote
.descsz
<= 0
1850 || inote
.type
!= NT_GNU_BUILD_ID
1851 || inote
.namesz
!= 4 /* sizeof "GNU" */
1852 || !startswith (inote
.namedata
, "GNU")
1853 || inote
.descsz
> 0x7ffffffe
1854 || size
< (12 + BFD_ALIGN (inote
.namesz
, 4) + inote
.descsz
))
1857 bfd_set_error (bfd_error_invalid_operation
);
1861 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) + inote
.descsz
);
1862 if (build_id
== NULL
)
1868 build_id
->size
= inote
.descsz
;
1869 memcpy (build_id
->data
, inote
.descdata
, inote
.descsz
);
1870 abfd
->build_id
= build_id
;
1876 /* Searches @var{abfd} for a build-id, and then constructs a pathname
1877 from it. The path is computed as .build-id/NN/NN+NN.debug where
1878 NNNN+NN is the build-id value as a hexadecimal string.
1880 Returns the constructed filename or NULL upon error. It is the
1881 caller's responsibility to free the memory used to hold the
1882 filename. If a filename is returned then the @var{build_id_out_p}
1883 parameter (which points to a @code{struct bfd_build_id} pointer) is
1884 set to a pointer to the build_id structure. */
1887 get_build_id_name (bfd
*abfd
, void *build_id_out_p
)
1889 struct bfd_build_id
**build_id_out
= build_id_out_p
;
1890 struct bfd_build_id
*build_id
;
1896 if (abfd
== NULL
|| bfd_get_filename (abfd
) == NULL
|| build_id_out
== NULL
)
1898 bfd_set_error (bfd_error_invalid_operation
);
1902 build_id
= get_build_id (abfd
);
1903 if (build_id
== NULL
)
1906 /* Compute the debug pathname corresponding to the build-id. */
1907 name
= bfd_malloc (strlen (".build-id/") + build_id
->size
* 2 + 2 + strlen (".debug"));
1910 bfd_set_error (bfd_error_no_memory
);
1917 n
+= sprintf (n
, ".build-id/");
1918 n
+= sprintf (n
, "%02x", (unsigned) *d
++); s
--;
1919 n
+= sprintf (n
, "/");
1921 n
+= sprintf (n
, "%02x", (unsigned) *d
++);
1922 n
+= sprintf (n
, ".debug");
1924 *build_id_out
= build_id
;
1928 /* Checks to see if @var{name} is a readable file and if its build-id
1929 matches @var{buildid}.
1931 Returns TRUE if the file exists, is readable, and contains a
1932 build-id which matches the build-id pointed at by @var{build_id_p}
1933 (which is really a @code{struct bfd_build_id **}). */
1936 check_build_id_file (const char *name
, void *buildid_p
)
1938 struct bfd_build_id
*orig_build_id
;
1939 struct bfd_build_id
*build_id
;
1944 BFD_ASSERT (buildid_p
);
1946 file
= bfd_openr (name
, NULL
);
1950 /* If the file is an archive, process all of its elements. */
1951 if (! bfd_check_format (file
, bfd_object
))
1957 build_id
= get_build_id (file
);
1958 if (build_id
== NULL
)
1964 orig_build_id
= *(struct bfd_build_id
**) buildid_p
;
1966 result
= build_id
->size
== orig_build_id
->size
1967 && memcmp (build_id
->data
, orig_build_id
->data
, build_id
->size
) == 0;
1969 (void) bfd_close (file
);
1976 bfd_follow_build_id_debuglink
1979 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
1982 Takes @var{abfd} and searches it for a .note.gnu.build-id section.
1983 If this section is found, it extracts the value of the NT_GNU_BUILD_ID
1984 note, which should be a hexadecimal value @var{NNNN+NN} (for
1985 32+ hex digits). It then searches the filesystem for a file named
1986 @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
1987 including the directory tree rooted at @var{dir}. The filename
1988 of the first matching file to be found is returned. A matching
1989 file should contain a .note.gnu.build-id section with the same
1990 @var{NNNN+NN} note as @var{abfd}, although this check is currently
1993 If @var{dir} is NULL, the search will take place starting at
1994 the current directory.
1996 Returns <<NULL>> on any errors or failure to locate the debug
1997 file, otherwise a pointer to a heap-allocated string
1998 containing the filename. The caller is responsible for
1999 freeing this string.
2003 bfd_follow_build_id_debuglink (bfd
*abfd
, const char *dir
)
2005 struct bfd_build_id
*build_id
;
2007 return find_separate_debug_file (abfd
, dir
, false,
2009 check_build_id_file
, &build_id
);
2017 const char *bfd_set_filename (bfd *abfd, const char *filename);
2020 Set the filename of @var{abfd}, copying the FILENAME parameter to
2021 bfd_alloc'd memory owned by @var{abfd}. Returns a pointer the
2022 newly allocated name, or NULL if the allocation failed.
2026 bfd_set_filename (bfd
*abfd
, const char *filename
)
2028 size_t len
= strlen (filename
) + 1;
2029 char *n
= bfd_alloc (abfd
, len
);
2034 if (abfd
->filename
!= NULL
)
2036 /* PR 29389. If we attempt to rename a file that has been closed due
2037 to caching, then we will not be able to reopen it later on. */
2038 if (abfd
->iostream
== NULL
&& (abfd
->flags
& BFD_CLOSED_BY_CACHE
))
2040 bfd_set_error (bfd_error_invalid_operation
);
2044 /* Similarly if we attempt to close a renamed file because the
2045 cache is now full, we will not be able to reopen it later on. */
2046 if (abfd
->iostream
!= NULL
)
2047 abfd
->cacheable
= 0;
2050 memcpy (n
, filename
, len
);