1 /* opncls.c -- open and close a BFD.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "libiberty.h"
31 #define S_IXUSR 0100 /* Execute by owner. */
34 #define S_IXGRP 0010 /* Execute by group. */
37 #define S_IXOTH 0001 /* Execute by others. */
40 /* Counters used to initialize the bfd identifier. */
42 static unsigned int bfd_id_counter
= 0;
43 static unsigned int bfd_reserved_id_counter
= 0;
47 .{* Set to N to open the next N BFDs using an alternate id space. *}
48 .extern unsigned int bfd_use_reserved_id;
50 unsigned int bfd_use_reserved_id
= 0;
52 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
53 if we do that we can't use fcntl. */
55 /* Return a new BFD. All BFD's are allocated through this routine. */
62 nbfd
= (bfd
*) bfd_zmalloc (sizeof (bfd
));
66 if (bfd_use_reserved_id
)
68 nbfd
->id
= --bfd_reserved_id_counter
;
69 --bfd_use_reserved_id
;
72 nbfd
->id
= bfd_id_counter
++;
74 nbfd
->memory
= objalloc_create ();
75 if (nbfd
->memory
== NULL
)
77 bfd_set_error (bfd_error_no_memory
);
82 nbfd
->arch_info
= &bfd_default_arch_struct
;
84 if (!bfd_hash_table_init_n (& nbfd
->section_htab
, bfd_section_hash_newfunc
,
85 sizeof (struct section_hash_entry
), 13))
94 static const struct bfd_iovec opncls_iovec
;
96 /* Allocate a new BFD as a member of archive OBFD. */
99 _bfd_new_bfd_contained_in (bfd
*obfd
)
103 nbfd
= _bfd_new_bfd ();
106 nbfd
->xvec
= obfd
->xvec
;
107 nbfd
->iovec
= obfd
->iovec
;
108 if (obfd
->iovec
== &opncls_iovec
)
109 nbfd
->iostream
= obfd
->iostream
;
110 nbfd
->my_archive
= obfd
;
111 nbfd
->direction
= read_direction
;
112 nbfd
->target_defaulted
= obfd
->target_defaulted
;
113 nbfd
->lto_output
= obfd
->lto_output
;
114 nbfd
->no_export
= obfd
->no_export
;
121 _bfd_delete_bfd (bfd
*abfd
)
125 bfd_hash_table_free (&abfd
->section_htab
);
126 objalloc_free ((struct objalloc
*) abfd
->memory
);
129 free (abfd
->arelt_data
);
133 /* Free objalloc memory. */
136 _bfd_free_cached_info (bfd
*abfd
)
140 bfd_hash_table_free (&abfd
->section_htab
);
141 objalloc_free ((struct objalloc
*) abfd
->memory
);
143 abfd
->sections
= NULL
;
144 abfd
->section_last
= NULL
;
145 abfd
->outsymbols
= NULL
;
146 abfd
->tdata
.any
= NULL
;
147 abfd
->usrdata
= NULL
;
156 Opening and closing BFDs
159 Functions for opening and closing
167 bfd *bfd_fopen (const char *filename, const char *target,
168 const char *mode, int fd);
171 Open the file @var{filename} with the target @var{target}.
172 Return a pointer to the created BFD. If @var{fd} is not -1,
173 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
174 is used. @var{mode} is passed directly to <<fopen>> or
177 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
180 The new BFD is marked as cacheable iff @var{fd} is -1.
182 If <<NULL>> is returned then an error has occured. Possible errors
183 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
184 <<system_call>> error.
186 On error, @var{fd} is always closed.
188 A copy of the @var{filename} argument is stored in the newly created
189 BFD. It can be accessed via the bfd_get_filename() macro.
193 bfd_fopen (const char *filename
, const char *target
, const char *mode
, int fd
)
196 const bfd_target
*target_vec
;
198 nbfd
= _bfd_new_bfd ();
206 target_vec
= bfd_find_target (target
, nbfd
);
207 if (target_vec
== NULL
)
211 _bfd_delete_bfd (nbfd
);
217 nbfd
->iostream
= fdopen (fd
, mode
);
220 nbfd
->iostream
= _bfd_real_fopen (filename
, mode
);
221 if (nbfd
->iostream
== NULL
)
223 bfd_set_error (bfd_error_system_call
);
226 _bfd_delete_bfd (nbfd
);
230 /* OK, put everything where it belongs. */
232 /* PR 11983: Do not cache the original filename, but
233 rather make a copy - the original might go away. */
234 if (!bfd_set_filename (nbfd
, filename
))
236 fclose (nbfd
->iostream
);
237 _bfd_delete_bfd (nbfd
);
241 /* Figure out whether the user is opening the file for reading,
242 writing, or both, by looking at the MODE argument. */
243 if ((mode
[0] == 'r' || mode
[0] == 'w' || mode
[0] == 'a')
245 nbfd
->direction
= both_direction
;
246 else if (mode
[0] == 'r')
247 nbfd
->direction
= read_direction
;
249 nbfd
->direction
= write_direction
;
251 if (!bfd_cache_init (nbfd
))
253 fclose (nbfd
->iostream
);
254 _bfd_delete_bfd (nbfd
);
257 nbfd
->opened_once
= TRUE
;
259 /* If we opened the file by name, mark it cacheable; we can close it
260 and reopen it later. However, if a file descriptor was provided,
261 then it may have been opened with special flags that make it
262 unsafe to close and reopen the file. */
264 (void) bfd_set_cacheable (nbfd
, TRUE
);
274 bfd *bfd_openr (const char *filename, const char *target);
277 Open the file @var{filename} (using <<fopen>>) with the target
278 @var{target}. Return a pointer to the created BFD.
280 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
283 If <<NULL>> is returned then an error has occured. Possible errors
284 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
285 <<system_call>> error.
287 A copy of the @var{filename} argument is stored in the newly created
288 BFD. It can be accessed via the bfd_get_filename() macro.
292 bfd_openr (const char *filename
, const char *target
)
294 return bfd_fopen (filename
, target
, FOPEN_RB
, -1);
297 /* Don't try to `optimize' this function:
299 o - We lock using stack space so that interrupting the locking
300 won't cause a storage leak.
301 o - We open the file stream last, since we don't want to have to
302 close it if anything goes wrong. Closing the stream means closing
303 the file descriptor too, even though we didn't open it. */
309 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
312 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
313 <<fopen>>. It opens a BFD on a file already described by the
316 When the file is later <<bfd_close>>d, the file descriptor will
317 be closed. If the caller desires that this file descriptor be
318 cached by BFD (opened as needed, closed as needed to free
319 descriptors for other opens), with the supplied @var{fd} used as
320 an initial file descriptor (but subject to closure at any time),
321 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
322 is to assume no caching; the file descriptor will remain open
323 until <<bfd_close>>, and will not be affected by BFD operations
326 Possible errors are <<bfd_error_no_memory>>,
327 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
329 On error, @var{fd} is closed.
331 A copy of the @var{filename} argument is stored in the newly created
332 BFD. It can be accessed via the bfd_get_filename() macro.
336 bfd_fdopenr (const char *filename
, const char *target
, int fd
)
339 #if defined(HAVE_FCNTL) && defined(F_GETFL)
343 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
344 mode
= FOPEN_RUB
; /* Assume full access. */
346 fdflags
= fcntl (fd
, F_GETFL
, NULL
);
353 bfd_set_error (bfd_error_system_call
);
357 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
358 switch (fdflags
& (O_ACCMODE
))
360 case O_RDONLY
: mode
= FOPEN_RB
; break;
361 case O_WRONLY
: mode
= FOPEN_RUB
; break;
362 case O_RDWR
: mode
= FOPEN_RUB
; break;
367 return bfd_fopen (filename
, target
, mode
, fd
);
375 bfd *bfd_openstreamr (const char * filename, const char * target,
379 Open a BFD for read access on an existing stdio stream. When
380 the BFD is passed to <<bfd_close>>, the stream will be closed.
382 A copy of the @var{filename} argument is stored in the newly created
383 BFD. It can be accessed via the bfd_get_filename() macro.
387 bfd_openstreamr (const char *filename
, const char *target
, void *streamarg
)
389 FILE *stream
= (FILE *) streamarg
;
391 const bfd_target
*target_vec
;
393 nbfd
= _bfd_new_bfd ();
397 target_vec
= bfd_find_target (target
, nbfd
);
398 if (target_vec
== NULL
)
400 _bfd_delete_bfd (nbfd
);
404 nbfd
->iostream
= stream
;
405 /* PR 11983: Do not cache the original filename, but
406 rather make a copy - the original might go away. */
407 if (!bfd_set_filename (nbfd
, filename
))
409 _bfd_delete_bfd (nbfd
);
412 nbfd
->direction
= read_direction
;
414 if (! bfd_cache_init (nbfd
))
416 _bfd_delete_bfd (nbfd
);
428 bfd *bfd_openr_iovec (const char *filename, const char *target,
429 void *(*open_func) (struct bfd *nbfd,
432 file_ptr (*pread_func) (struct bfd *nbfd,
437 int (*close_func) (struct bfd *nbfd,
439 int (*stat_func) (struct bfd *abfd,
444 Create and return a BFD backed by a read-only @var{stream}.
445 The @var{stream} is created using @var{open_func}, accessed using
446 @var{pread_func} and destroyed using @var{close_func}.
448 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
451 Calls @var{open_func} (which can call <<bfd_zalloc>> and
452 <<bfd_get_filename>>) to obtain the read-only stream backing
453 the BFD. @var{open_func} either succeeds returning the
454 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
455 (setting <<bfd_error>>).
457 Calls @var{pread_func} to request @var{nbytes} of data from
458 @var{stream} starting at @var{offset} (e.g., via a call to
459 <<bfd_read>>). @var{pread_func} either succeeds returning the
460 number of bytes read (which can be less than @var{nbytes} when
461 end-of-file), or fails returning -1 (setting <<bfd_error>>).
463 Calls @var{close_func} when the BFD is later closed using
464 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
465 fails returning -1 (setting <<bfd_error>>).
467 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
468 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
469 on success, or returns -1 on failure (setting <<bfd_error>>).
471 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
472 occurred. Possible errors are <<bfd_error_no_memory>>,
473 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
475 A copy of the @var{filename} argument is stored in the newly created
476 BFD. It can be accessed via the bfd_get_filename() macro.
482 file_ptr (*pread
) (struct bfd
*abfd
, void *stream
, void *buf
,
483 file_ptr nbytes
, file_ptr offset
);
484 int (*close
) (struct bfd
*abfd
, void *stream
);
485 int (*stat
) (struct bfd
*abfd
, void *stream
, struct stat
*sb
);
490 opncls_btell (struct bfd
*abfd
)
492 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
497 opncls_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
499 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
502 case SEEK_SET
: vec
->where
= offset
; break;
503 case SEEK_CUR
: vec
->where
+= offset
; break;
504 case SEEK_END
: return -1;
510 opncls_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
512 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
513 file_ptr nread
= (vec
->pread
) (abfd
, vec
->stream
, buf
, nbytes
, vec
->where
);
522 opncls_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
523 const void *where ATTRIBUTE_UNUSED
,
524 file_ptr nbytes ATTRIBUTE_UNUSED
)
530 opncls_bclose (struct bfd
*abfd
)
532 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
533 /* Since the VEC's memory is bound to the bfd deleting the bfd will
537 if (vec
->close
!= NULL
)
538 status
= (vec
->close
) (abfd
, vec
->stream
);
539 abfd
->iostream
= NULL
;
544 opncls_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
550 opncls_bstat (struct bfd
*abfd
, struct stat
*sb
)
552 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
554 memset (sb
, 0, sizeof (*sb
));
555 if (vec
->stat
== NULL
)
558 return (vec
->stat
) (abfd
, vec
->stream
, sb
);
562 opncls_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
563 void *addr ATTRIBUTE_UNUSED
,
564 bfd_size_type len ATTRIBUTE_UNUSED
,
565 int prot ATTRIBUTE_UNUSED
,
566 int flags ATTRIBUTE_UNUSED
,
567 file_ptr offset ATTRIBUTE_UNUSED
,
568 void **map_addr ATTRIBUTE_UNUSED
,
569 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
574 static const struct bfd_iovec opncls_iovec
=
576 &opncls_bread
, &opncls_bwrite
, &opncls_btell
, &opncls_bseek
,
577 &opncls_bclose
, &opncls_bflush
, &opncls_bstat
, &opncls_bmmap
581 bfd_openr_iovec (const char *filename
, const char *target
,
582 void *(*open_p
) (struct bfd
*, void *),
584 file_ptr (*pread_p
) (struct bfd
*, void *, void *,
586 int (*close_p
) (struct bfd
*, void *),
587 int (*stat_p
) (struct bfd
*, void *, struct stat
*))
590 const bfd_target
*target_vec
;
594 nbfd
= _bfd_new_bfd ();
598 target_vec
= bfd_find_target (target
, nbfd
);
599 if (target_vec
== NULL
)
601 _bfd_delete_bfd (nbfd
);
605 /* PR 11983: Do not cache the original filename, but
606 rather make a copy - the original might go away. */
607 if (!bfd_set_filename (nbfd
, filename
))
609 _bfd_delete_bfd (nbfd
);
612 nbfd
->direction
= read_direction
;
614 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
615 stream
= (*open_p
) (nbfd
, open_closure
);
618 _bfd_delete_bfd (nbfd
);
622 vec
= (struct opncls
*) bfd_zalloc (nbfd
, sizeof (struct opncls
));
623 vec
->stream
= stream
;
624 vec
->pread
= pread_p
;
625 vec
->close
= close_p
;
628 nbfd
->iovec
= &opncls_iovec
;
629 nbfd
->iostream
= vec
;
634 /* bfd_openw -- open for writing.
635 Returns a pointer to a freshly-allocated BFD on success, or NULL.
637 See comment by bfd_fdopenr before you try to modify this function. */
644 bfd *bfd_openw (const char *filename, const char *target);
647 Create a BFD, associated with file @var{filename}, using the
648 file format @var{target}, and return a pointer to it.
650 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
651 <<bfd_error_invalid_target>>.
653 A copy of the @var{filename} argument is stored in the newly created
654 BFD. It can be accessed via the bfd_get_filename() macro.
658 bfd_openw (const char *filename
, const char *target
)
661 const bfd_target
*target_vec
;
663 /* nbfd has to point to head of malloc'ed block so that bfd_close may
664 reclaim it correctly. */
665 nbfd
= _bfd_new_bfd ();
669 target_vec
= bfd_find_target (target
, nbfd
);
670 if (target_vec
== NULL
)
672 _bfd_delete_bfd (nbfd
);
676 /* PR 11983: Do not cache the original filename, but
677 rather make a copy - the original might go away. */
678 if (!bfd_set_filename (nbfd
, filename
))
680 _bfd_delete_bfd (nbfd
);
683 nbfd
->direction
= write_direction
;
685 if (bfd_open_file (nbfd
) == NULL
)
687 /* File not writeable, etc. */
688 bfd_set_error (bfd_error_system_call
);
689 _bfd_delete_bfd (nbfd
);
697 _maybe_make_executable (bfd
* abfd
)
699 /* If the file was open for writing and is now executable,
701 if (abfd
->direction
== write_direction
702 && (abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
706 if (stat (bfd_get_filename (abfd
), &buf
) == 0
707 /* Do not attempt to change non-regular files. This is
708 here especially for configure scripts and kernel builds
709 which run tests with "ld [...] -o /dev/null". */
710 && S_ISREG(buf
.st_mode
))
712 unsigned int mask
= umask (0);
715 chmod (bfd_get_filename (abfd
),
717 & (buf
.st_mode
| ((S_IXUSR
| S_IXGRP
| S_IXOTH
) &~ mask
))));
727 bfd_boolean bfd_close (bfd *abfd);
730 Close a BFD. If the BFD was open for writing, then pending
731 operations are completed and the file written out and closed.
732 If the created file is executable, then <<chmod>> is called
735 All memory attached to the BFD is released.
737 The file descriptor associated with the BFD is closed (even
738 if it was passed in to BFD by <<bfd_fdopenr>>).
741 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
745 bfd_close (bfd
*abfd
)
747 if (bfd_write_p (abfd
))
749 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
753 return bfd_close_all_done (abfd
);
761 bfd_boolean bfd_close_all_done (bfd *);
764 Close a BFD. Differs from <<bfd_close>> since it does not
765 complete any pending operations. This routine would be used
766 if the application had just used BFD for swapping and didn't
767 want to use any of the writing code.
769 If the created file is executable, then <<chmod>> is called
772 All memory attached to the BFD is released.
775 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
779 bfd_close_all_done (bfd
*abfd
)
783 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
786 ret
= abfd
->iovec
->bclose (abfd
) == 0;
789 _maybe_make_executable (abfd
);
791 _bfd_delete_bfd (abfd
);
801 bfd *bfd_create (const char *filename, bfd *templ);
804 Create a new BFD in the manner of <<bfd_openw>>, but without
805 opening a file. The new BFD takes the target from the target
806 used by @var{templ}. The format is always set to <<bfd_object>>.
808 A copy of the @var{filename} argument is stored in the newly created
809 BFD. It can be accessed via the bfd_get_filename() macro.
813 bfd_create (const char *filename
, bfd
*templ
)
817 nbfd
= _bfd_new_bfd ();
820 /* PR 11983: Do not cache the original filename, but
821 rather make a copy - the original might go away. */
822 if (!bfd_set_filename (nbfd
, filename
))
824 _bfd_delete_bfd (nbfd
);
828 nbfd
->xvec
= templ
->xvec
;
829 nbfd
->direction
= no_direction
;
830 bfd_set_format (nbfd
, bfd_object
);
840 bfd_boolean bfd_make_writable (bfd *abfd);
843 Takes a BFD as created by <<bfd_create>> and converts it
844 into one like as returned by <<bfd_openw>>. It does this
845 by converting the BFD to BFD_IN_MEMORY. It's assumed that
846 you will call <<bfd_make_readable>> on this bfd later.
849 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
853 bfd_make_writable (bfd
*abfd
)
855 struct bfd_in_memory
*bim
;
857 if (abfd
->direction
!= no_direction
)
859 bfd_set_error (bfd_error_invalid_operation
);
863 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
865 return FALSE
; /* bfd_error already set. */
866 abfd
->iostream
= bim
;
867 /* bfd_bwrite will grow these as needed. */
871 abfd
->flags
|= BFD_IN_MEMORY
;
872 abfd
->iovec
= &_bfd_memory_iovec
;
874 abfd
->direction
= write_direction
;
885 bfd_boolean bfd_make_readable (bfd *abfd);
888 Takes a BFD as created by <<bfd_create>> and
889 <<bfd_make_writable>> and converts it into one like as
890 returned by <<bfd_openr>>. It does this by writing the
891 contents out to the memory buffer, then reversing the
895 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
898 bfd_make_readable (bfd
*abfd
)
900 if (abfd
->direction
!= write_direction
|| !(abfd
->flags
& BFD_IN_MEMORY
))
902 bfd_set_error (bfd_error_invalid_operation
);
906 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
909 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
912 abfd
->arch_info
= &bfd_default_arch_struct
;
915 abfd
->format
= bfd_unknown
;
916 abfd
->my_archive
= NULL
;
918 abfd
->opened_once
= FALSE
;
919 abfd
->output_has_begun
= FALSE
;
920 abfd
->section_count
= 0;
921 abfd
->usrdata
= NULL
;
922 abfd
->cacheable
= FALSE
;
923 abfd
->flags
|= BFD_IN_MEMORY
;
924 abfd
->mtime_set
= FALSE
;
926 abfd
->target_defaulted
= TRUE
;
927 abfd
->direction
= read_direction
;
930 abfd
->outsymbols
= 0;
933 bfd_section_list_clear (abfd
);
934 bfd_check_format (abfd
, bfd_object
);
944 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
947 Allocate a block of @var{wanted} bytes of memory attached to
948 <<abfd>> and return a pointer to it.
952 bfd_alloc (bfd
*abfd
, bfd_size_type size
)
955 unsigned long ul_size
= (unsigned long) size
;
958 /* Note - although objalloc_alloc takes an unsigned long as its
959 argument, internally the size is treated as a signed long. This can
960 lead to problems where, for example, a request to allocate -1 bytes
961 can result in just 1 byte being allocated, rather than
962 ((unsigned long) -1) bytes. Also memory checkers will often
963 complain about attempts to allocate a negative amount of memory.
964 So to stop these problems we fail if the size is negative. */
965 || ((signed long) ul_size
) < 0)
967 bfd_set_error (bfd_error_no_memory
);
971 ret
= objalloc_alloc ((struct objalloc
*) abfd
->memory
, ul_size
);
973 bfd_set_error (bfd_error_no_memory
);
982 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
985 Allocate a block of @var{wanted} bytes of zeroed memory
986 attached to <<abfd>> and return a pointer to it.
990 bfd_zalloc (bfd
*abfd
, bfd_size_type size
)
994 res
= bfd_alloc (abfd
, size
);
996 memset (res
, 0, (size_t) size
);
1000 /* Free a block allocated for a BFD.
1001 Note: Also frees all more recently allocated blocks! */
1004 bfd_release (bfd
*abfd
, void *block
)
1006 objalloc_free_block ((struct objalloc
*) abfd
->memory
, block
);
1011 GNU Extension: separate debug-info files
1013 The idea here is that a special section called .gnu_debuglink might be
1014 embedded in a binary file, which indicates that some *other* file
1015 contains the real debugging information. This special section contains a
1016 filename and CRC32 checksum, which we read and resolve to another file,
1019 This facilitates "optional" provision of debugging information, without
1020 having to provide two complete copies of every binary object (with and
1021 without debug symbols). */
1023 #define GNU_DEBUGLINK ".gnu_debuglink"
1024 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1028 bfd_calc_gnu_debuglink_crc32
1031 unsigned long bfd_calc_gnu_debuglink_crc32
1032 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1035 Computes a CRC value as used in the .gnu_debuglink section.
1036 Advances the previously computed @var{crc} value by computing
1037 and adding in the crc32 for @var{len} bytes of @var{buf}.
1040 Return the updated CRC32 value.
1044 bfd_calc_gnu_debuglink_crc32 (unsigned long crc
,
1045 const unsigned char *buf
,
1048 static const unsigned long crc32_table
[256] =
1050 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1051 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1052 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1053 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1054 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1055 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1056 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1057 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1058 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1059 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1060 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1061 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1062 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1063 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1064 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1065 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1066 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1067 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1068 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1069 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1070 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1071 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1072 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1073 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1074 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1075 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1076 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1077 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1078 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1079 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1080 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1081 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1082 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1083 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1084 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1085 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1086 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1087 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1088 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1089 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1090 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1091 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1092 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1093 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1094 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1095 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1096 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1097 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1098 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1099 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1100 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1103 const unsigned char *end
;
1105 crc
= ~crc
& 0xffffffff;
1106 for (end
= buf
+ len
; buf
< end
; ++ buf
)
1107 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
1108 return ~crc
& 0xffffffff;
1114 bfd_get_debug_link_info_1
1117 char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out);
1120 Extracts the filename and CRC32 value for any separate debug
1121 information file associated with @var{abfd}.
1123 The @var{crc32_out} parameter is an untyped pointer because
1124 this routine is used as a @code{get_func_type} function, but it
1125 is expected to be an unsigned long pointer.
1128 The filename of the associated debug information file, or NULL
1129 if there is no such file. If the filename was found then the
1130 contents of @var{crc32_out} are updated to hold the corresponding
1131 CRC32 value for the file.
1133 The returned filename is allocated with @code{malloc}; freeing
1134 it is the responsibility of the caller.
1138 bfd_get_debug_link_info_1 (bfd
*abfd
, void *crc32_out
)
1141 unsigned long *crc32
= (unsigned long *) crc32_out
;
1143 unsigned int crc_offset
;
1146 ufile_ptr file_size
;
1149 BFD_ASSERT (crc32_out
);
1151 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1156 size
= bfd_section_size (sect
);
1157 file_size
= bfd_get_size (abfd
);
1159 /* PR 22794: Make sure that the section has a reasonable size. */
1160 if (size
< 8 || (file_size
!= 0 && size
>= file_size
))
1163 if (!bfd_malloc_and_get_section (abfd
, sect
, &contents
))
1169 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1170 name
= (char *) contents
;
1171 /* PR 17597: Avoid reading off the end of the buffer. */
1172 crc_offset
= strnlen (name
, size
) + 1;
1173 crc_offset
= (crc_offset
+ 3) & ~3;
1174 if (crc_offset
+ 4 > size
)
1177 *crc32
= bfd_get_32 (abfd
, contents
+ crc_offset
);
1184 bfd_get_debug_link_info
1187 char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1190 Extracts the filename and CRC32 value for any separate debug
1191 information file associated with @var{abfd}.
1194 The filename of the associated debug information file, or NULL
1195 if there is no such file. If the filename was found then the
1196 contents of @var{crc32_out} are updated to hold the corresponding
1197 CRC32 value for the file.
1199 The returned filename is allocated with @code{malloc}; freeing
1200 it is the responsibility of the caller.
1204 bfd_get_debug_link_info (bfd
*abfd
, unsigned long *crc32_out
)
1206 return bfd_get_debug_link_info_1 (abfd
, crc32_out
);
1211 bfd_get_alt_debug_link_info
1214 char *bfd_get_alt_debug_link_info (bfd * abfd,
1215 bfd_size_type *buildid_len,
1216 bfd_byte **buildid_out);
1219 Fetch the filename and BuildID value for any alternate debuginfo
1220 associated with @var{abfd}. Return NULL if no such info found,
1221 otherwise return filename and update @var{buildid_len} and
1222 @var{buildid_out}. The returned filename and build_id are
1223 allocated with @code{malloc}; freeing them is the responsibility
1228 bfd_get_alt_debug_link_info (bfd
* abfd
, bfd_size_type
*buildid_len
,
1229 bfd_byte
**buildid_out
)
1233 unsigned int buildid_offset
;
1236 ufile_ptr file_size
;
1239 BFD_ASSERT (buildid_len
);
1240 BFD_ASSERT (buildid_out
);
1242 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGALTLINK
);
1247 size
= bfd_section_size (sect
);
1248 file_size
= bfd_get_size (abfd
);
1249 if (size
< 8 || (file_size
!= 0 && size
>= file_size
))
1252 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1258 /* BuildID value is stored after the filename. */
1259 name
= (char *) contents
;
1260 buildid_offset
= strnlen (name
, size
) + 1;
1261 if (buildid_offset
>= bfd_section_size (sect
))
1264 *buildid_len
= size
- buildid_offset
;
1265 *buildid_out
= bfd_malloc (*buildid_len
);
1266 memcpy (*buildid_out
, contents
+ buildid_offset
, *buildid_len
);
1273 separate_debug_file_exists
1276 bfd_boolean separate_debug_file_exists
1277 (char *name, void *crc32_p);
1280 Checks to see if @var{name} is a file and if its contents
1281 match @var{crc32}, which is a pointer to an @code{unsigned
1282 long} containing a CRC32.
1284 The @var{crc32_p} parameter is an untyped pointer because
1285 this routine is used as a @code{check_func_type} function.
1289 separate_debug_file_exists (const char *name
, void *crc32_p
)
1291 static unsigned char buffer
[8 * 1024];
1292 unsigned long file_crc
= 0;
1294 bfd_size_type count
;
1298 BFD_ASSERT (crc32_p
);
1300 crc
= *(unsigned long *) crc32_p
;
1302 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1306 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
1307 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1311 return crc
== file_crc
;
1316 separate_alt_debug_file_exists
1319 bfd_boolean separate_alt_debug_file_exists
1320 (char *name, void *unused);
1323 Checks to see if @var{name} is a file.
1327 separate_alt_debug_file_exists (const char *name
, void *unused ATTRIBUTE_UNUSED
)
1333 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1344 find_separate_debug_file
1347 char *find_separate_debug_file
1348 (bfd *abfd, const char *dir, bfd_boolean include_dirs,
1349 get_func_type get, check_func_type check, void *data);
1352 Searches for a debug information file corresponding to @var{abfd}.
1354 The name of the separate debug info file is returned by the
1355 @var{get} function. This function scans various fixed locations
1356 in the filesystem, including the file tree rooted at @var{dir}.
1357 If the @var{include_dirs} parameter is true then the directory
1358 components of @var{abfd}'s filename will be included in the
1361 @var{data} is passed unmodified to the @var{get} and @var{check}
1362 functions. It is generally used to implement build-id-like
1363 matching in the callback functions.
1366 Returns the filename of the first file to be found which
1367 receives a TRUE result from the @var{check} function.
1368 Returns NULL if no valid file could be found.
1371 typedef char * (* get_func_type
) (bfd
*, void *);
1372 typedef bfd_boolean (* check_func_type
) (const char *, void *);
1375 find_separate_debug_file (bfd
* abfd
,
1376 const char * debug_file_directory
,
1377 bfd_boolean include_dirs
,
1378 get_func_type get_func
,
1379 check_func_type check_func
,
1387 size_t canon_dirlen
;
1390 if (debug_file_directory
== NULL
)
1391 debug_file_directory
= ".";
1393 /* BFD may have been opened from a stream. */
1394 if (bfd_get_filename (abfd
) == NULL
)
1396 bfd_set_error (bfd_error_invalid_operation
);
1400 base
= get_func (abfd
, func_data
);
1405 if (base
[0] == '\0')
1408 bfd_set_error (bfd_error_no_debug_section
);
1414 const char *fname
= bfd_get_filename (abfd
);
1415 for (dirlen
= strlen (fname
); dirlen
> 0; dirlen
--)
1416 if (IS_DIR_SEPARATOR (fname
[dirlen
- 1]))
1419 dir
= (char *) bfd_malloc (dirlen
+ 1);
1425 memcpy (dir
, fname
, dirlen
);
1430 dir
= (char *) bfd_malloc (1);
1435 /* Compute the canonical name of the bfd object with all symbolic links
1436 resolved, for use in the global debugfile directory. */
1437 canon_dir
= lrealpath (bfd_get_filename (abfd
));
1438 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
1439 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
1441 canon_dir
[canon_dirlen
] = '\0';
1443 #ifndef EXTRA_DEBUG_ROOT1
1444 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1446 #ifndef EXTRA_DEBUG_ROOT2
1447 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1450 debugfile
= (char *)
1451 bfd_malloc (strlen (debug_file_directory
) + 1
1452 + (canon_dirlen
> dirlen
? canon_dirlen
: dirlen
)
1453 + strlen (".debug/")
1454 #ifdef EXTRA_DEBUG_ROOT1
1455 + strlen (EXTRA_DEBUG_ROOT1
)
1457 #ifdef EXTRA_DEBUG_ROOT2
1458 + strlen (EXTRA_DEBUG_ROOT2
)
1462 if (debugfile
== NULL
)
1463 goto found
; /* Actually this returns NULL. */
1465 /* First try in the same directory as the original file.
1467 FIXME: Strictly speaking if we are using the build-id method,
1468 (ie include_dirs == FALSE) then we should only check absolute
1469 paths, not relative ones like this one (and the next one).
1470 The check is left in however as this allows the binutils
1471 testsuite to exercise this feature without having to install
1472 a file into the root filesystem. (See binutils/testsuite/
1473 binutils-all/objdump.exp for the test). */
1474 sprintf (debugfile
, "%s%s", dir
, base
);
1475 if (check_func (debugfile
, func_data
))
1478 /* Then try in a subdirectory called .debug. */
1479 sprintf (debugfile
, "%s.debug/%s", dir
, base
);
1480 if (check_func (debugfile
, func_data
))
1483 #ifdef EXTRA_DEBUG_ROOT1
1484 /* Try the first extra debug file root. */
1485 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT1
,
1486 include_dirs
? canon_dir
: "/", base
);
1487 if (check_func (debugfile
, func_data
))
1491 #ifdef EXTRA_DEBUG_ROOT2
1492 /* Try the second extra debug file root. */
1493 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT2
,
1494 include_dirs
? canon_dir
: "/", base
);
1495 if (check_func (debugfile
, func_data
))
1499 /* Then try in the global debugfile directory. */
1500 strcpy (debugfile
, debug_file_directory
);
1501 dirlen
= strlen (debug_file_directory
) - 1;
1505 && debug_file_directory
[dirlen
] != '/'
1506 && canon_dir
[0] != '/')
1507 strcat (debugfile
, "/");
1508 strcat (debugfile
, canon_dir
);
1512 if (dirlen
> 0 && debug_file_directory
[dirlen
] != '/')
1513 strcat (debugfile
, "/");
1515 strcat (debugfile
, base
);
1517 if (check_func (debugfile
, func_data
))
1520 /* Failed to find the file. */
1533 bfd_follow_gnu_debuglink
1536 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1539 Takes a BFD and searches it for a .gnu_debuglink section. If this
1540 section is found, it examines the section for the name and checksum
1541 of a '.debug' file containing auxiliary debugging information. It
1542 then searches the filesystem for this .debug file in some standard
1543 locations, including the directory tree rooted at @var{dir}, and if
1544 found returns the full filename.
1546 If @var{dir} is NULL, the search will take place starting at
1547 the current directory.
1550 <<NULL>> on any errors or failure to locate the .debug file,
1551 otherwise a pointer to a heap-allocated string containing the
1552 filename. The caller is responsible for freeing this string.
1556 bfd_follow_gnu_debuglink (bfd
*abfd
, const char *dir
)
1558 unsigned long crc32
;
1560 return find_separate_debug_file (abfd
, dir
, TRUE
,
1561 bfd_get_debug_link_info_1
,
1562 separate_debug_file_exists
, &crc32
);
1565 /* Helper for bfd_follow_gnu_debugaltlink. It just returns the name
1566 of the separate debug file. */
1569 get_alt_debug_link_info_shim (bfd
* abfd
, void *unused ATTRIBUTE_UNUSED
)
1572 bfd_byte
*buildid
= NULL
;
1573 char *result
= bfd_get_alt_debug_link_info (abfd
, &len
, &buildid
);
1582 bfd_follow_gnu_debugaltlink
1585 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1588 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1589 section is found, it examines the section for the name of a file
1590 containing auxiliary debugging information. It then searches the
1591 filesystem for this file in a set of standard locations, including
1592 the directory tree rooted at @var{dir}, and if found returns the
1595 If @var{dir} is NULL, the search will take place starting at
1596 the current directory.
1599 <<NULL>> on any errors or failure to locate the debug file,
1600 otherwise a pointer to a heap-allocated string containing the
1601 filename. The caller is responsible for freeing this string.
1605 bfd_follow_gnu_debugaltlink (bfd
*abfd
, const char *dir
)
1607 return find_separate_debug_file (abfd
, dir
, TRUE
,
1608 get_alt_debug_link_info_shim
,
1609 separate_alt_debug_file_exists
,
1615 bfd_create_gnu_debuglink_section
1618 struct bfd_section *bfd_create_gnu_debuglink_section
1619 (bfd *abfd, const char *filename);
1622 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The
1623 section is sized to be big enough to contain a link to the specified
1627 A pointer to the new section is returned if all is ok. Otherwise
1628 <<NULL>> is returned and bfd_error is set.
1632 bfd_create_gnu_debuglink_section (bfd
*abfd
, const char *filename
)
1635 bfd_size_type debuglink_size
;
1638 if (abfd
== NULL
|| filename
== NULL
)
1640 bfd_set_error (bfd_error_invalid_operation
);
1644 /* Strip off any path components in filename. */
1645 filename
= lbasename (filename
);
1647 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1650 /* Section already exists. */
1651 bfd_set_error (bfd_error_invalid_operation
);
1655 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DEBUGGING
;
1656 sect
= bfd_make_section_with_flags (abfd
, GNU_DEBUGLINK
, flags
);
1660 /* Compute the size of the section. Allow for the CRC after the filename,
1661 and padding so that it will start on a 4-byte boundary. */
1662 debuglink_size
= strlen (filename
) + 1;
1663 debuglink_size
+= 3;
1664 debuglink_size
&= ~3;
1665 debuglink_size
+= 4;
1667 if (!bfd_set_section_size (sect
, debuglink_size
))
1668 /* XXX Should we delete the section from the bfd ? */
1671 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1672 Note - despite the name of the function being called, we are
1673 setting an alignment power, not a byte alignment value. */
1674 bfd_set_section_alignment (sect
, 2);
1682 bfd_fill_in_gnu_debuglink_section
1685 bfd_boolean bfd_fill_in_gnu_debuglink_section
1686 (bfd *abfd, struct bfd_section *sect, const char *filename);
1689 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1690 and fills in the contents of the section to contain a link to the
1691 specified @var{filename}. The filename should be relative to the
1695 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1696 and bfd_error is set.
1700 bfd_fill_in_gnu_debuglink_section (bfd
*abfd
,
1701 struct bfd_section
*sect
,
1702 const char *filename
)
1704 bfd_size_type debuglink_size
;
1705 unsigned long crc32
;
1707 bfd_size_type crc_offset
;
1709 static unsigned char buffer
[8 * 1024];
1713 if (abfd
== NULL
|| sect
== NULL
|| filename
== NULL
)
1715 bfd_set_error (bfd_error_invalid_operation
);
1719 /* Make sure that we can read the file.
1720 XXX - Should we attempt to locate the debug info file using the same
1721 algorithm as gdb ? At the moment, since we are creating the
1722 .gnu_debuglink section, we insist upon the user providing us with a
1723 correct-for-section-creation-time path, but this need not conform to
1724 the gdb location algorithm. */
1725 handle
= _bfd_real_fopen (filename
, FOPEN_RB
);
1728 bfd_set_error (bfd_error_system_call
);
1733 while ((count
= fread (buffer
, 1, sizeof buffer
, handle
)) > 0)
1734 crc32
= bfd_calc_gnu_debuglink_crc32 (crc32
, buffer
, count
);
1737 /* Strip off any path components in filename,
1738 now that we no longer need them. */
1739 filename
= lbasename (filename
);
1741 filelen
= strlen (filename
);
1742 debuglink_size
= filelen
+ 1;
1743 debuglink_size
+= 3;
1744 debuglink_size
&= ~3;
1745 debuglink_size
+= 4;
1747 contents
= (char *) bfd_malloc (debuglink_size
);
1748 if (contents
== NULL
)
1750 /* XXX Should we delete the section from the bfd ? */
1754 crc_offset
= debuglink_size
- 4;
1755 memcpy (contents
, filename
, filelen
);
1756 memset (contents
+ filelen
, 0, crc_offset
- filelen
);
1758 bfd_put_32 (abfd
, crc32
, contents
+ crc_offset
);
1760 if (! bfd_set_section_contents (abfd
, sect
, contents
, 0, debuglink_size
))
1762 /* XXX Should we delete the section from the bfd ? */
1775 struct bfd_build_id * get_build_id (bfd *abfd);
1778 Finds the build-id associated with @var{abfd}. If the build-id is
1779 extracted from the note section then a build-id structure is built
1780 for it, using memory allocated to @var{abfd}, and this is then
1781 attached to the @var{abfd}.
1784 Returns a pointer to the build-id structure if a build-id could be
1785 found. If no build-id is found NULL is returned and error code is
1789 static struct bfd_build_id
*
1790 get_build_id (bfd
*abfd
)
1792 struct bfd_build_id
*build_id
;
1793 Elf_Internal_Note inote
;
1794 Elf_External_Note
*enote
;
1801 if (abfd
->build_id
&& abfd
->build_id
->size
> 0)
1802 /* Save some time by using the already computed build-id. */
1803 return (struct bfd_build_id
*) abfd
->build_id
;
1805 sect
= bfd_get_section_by_name (abfd
, ".note.gnu.build-id");
1808 bfd_set_error (bfd_error_no_debug_section
);
1812 size
= bfd_section_size (sect
);
1813 /* FIXME: Should we support smaller build-id notes ? */
1816 bfd_set_error (bfd_error_invalid_operation
);
1820 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 || strncmp (inote
.namedata
, "GNU", 4) != 0
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
;
1877 char * get_build_id_name (bfd *abfd, void *build_id_out_p)
1880 Searches @var{abfd} for a build-id, and then constructs a pathname
1881 from it. The path is computed as .build-id/NN/NN+NN.debug where
1882 NNNN+NN is the build-id value as a hexadecimal string.
1885 Returns the constructed filename or NULL upon error.
1886 It is the caller's responsibility to free the memory used to hold the
1888 If a filename is returned then the @var{build_id_out_p}
1889 parameter (which points to a @code{struct bfd_build_id}
1890 pointer) is set to a pointer to the build_id structure.
1894 get_build_id_name (bfd
*abfd
, void *build_id_out_p
)
1896 struct bfd_build_id
**build_id_out
= build_id_out_p
;
1897 struct bfd_build_id
*build_id
;
1903 if (abfd
== NULL
|| bfd_get_filename (abfd
) == NULL
|| build_id_out
== NULL
)
1905 bfd_set_error (bfd_error_invalid_operation
);
1909 build_id
= get_build_id (abfd
);
1910 if (build_id
== NULL
)
1913 /* Compute the debug pathname corresponding to the build-id. */
1914 name
= bfd_malloc (strlen (".build-id/") + build_id
->size
* 2 + 2 + strlen (".debug"));
1917 bfd_set_error (bfd_error_no_memory
);
1924 n
+= sprintf (n
, ".build-id/");
1925 n
+= sprintf (n
, "%02x", (unsigned) *d
++); s
--;
1926 n
+= sprintf (n
, "/");
1928 n
+= sprintf (n
, "%02x", (unsigned) *d
++);
1929 n
+= sprintf (n
, ".debug");
1931 *build_id_out
= build_id
;
1940 bfd_boolean check_build_id_file (char *name, void *buildid_p);
1943 Checks to see if @var{name} is a readable file and if its build-id
1944 matches @var{buildid}.
1947 Returns TRUE if the file exists, is readable, and contains a
1948 build-id which matches the build-id pointed at by
1949 @var{build_id_p} (which is really a @code{struct bfd_build_id **}).
1953 check_build_id_file (const char *name
, void *buildid_p
)
1955 struct bfd_build_id
*orig_build_id
;
1956 struct bfd_build_id
*build_id
;
1961 BFD_ASSERT (buildid_p
);
1963 file
= bfd_openr (name
, NULL
);
1967 /* If the file is an archive, process all of its elements. */
1968 if (! bfd_check_format (file
, bfd_object
))
1974 build_id
= get_build_id (file
);
1975 if (build_id
== NULL
)
1981 orig_build_id
= *(struct bfd_build_id
**) buildid_p
;
1983 result
= build_id
->size
== orig_build_id
->size
1984 && memcmp (build_id
->data
, orig_build_id
->data
, build_id
->size
) == 0;
1986 (void) bfd_close (file
);
1993 bfd_follow_build_id_debuglink
1996 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
1999 Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2000 If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2001 note, which should be a hexadecimal value @var{NNNN+NN} (for
2002 32+ hex digits). It then searches the filesystem for a file named
2003 @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2004 including the directory tree rooted at @var{dir}. The filename
2005 of the first matching file to be found is returned. A matching
2006 file should contain a .note.gnu.build-id section with the same
2007 @var{NNNN+NN} note as @var{abfd}, although this check is currently
2010 If @var{dir} is NULL, the search will take place starting at
2011 the current directory.
2014 <<NULL>> on any errors or failure to locate the debug file,
2015 otherwise a pointer to a heap-allocated string containing the
2016 filename. The caller is responsible for freeing this string.
2020 bfd_follow_build_id_debuglink (bfd
*abfd
, const char *dir
)
2022 struct bfd_build_id
*build_id
;
2024 return find_separate_debug_file (abfd
, dir
, FALSE
,
2026 check_build_id_file
, &build_id
);
2034 const char *bfd_set_filename (bfd *abfd, const char *filename);
2037 Set the filename of @var{abfd}, copying the FILENAME parameter to
2038 bfd_alloc'd memory owned by @var{abfd}. Returns a pointer the
2039 newly allocated name, or NULL if the allocation failed.
2043 bfd_set_filename (bfd
*abfd
, const char *filename
)
2045 size_t len
= strlen (filename
) + 1;
2046 char *n
= bfd_alloc (abfd
, len
);
2049 memcpy (n
, filename
, len
);