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 ((char *) bfd_get_filename (abfd
));
130 free (abfd
->arelt_data
);
134 /* Free objalloc memory. */
137 _bfd_free_cached_info (bfd
*abfd
)
141 bfd_hash_table_free (&abfd
->section_htab
);
142 objalloc_free ((struct objalloc
*) abfd
->memory
);
144 abfd
->sections
= NULL
;
145 abfd
->section_last
= NULL
;
146 abfd
->outsymbols
= NULL
;
147 abfd
->tdata
.any
= NULL
;
148 abfd
->usrdata
= NULL
;
157 Opening and closing BFDs
160 Functions for opening and closing
168 bfd *bfd_fopen (const char *filename, const char *target,
169 const char *mode, int fd);
172 Open the file @var{filename} with the target @var{target}.
173 Return a pointer to the created BFD. If @var{fd} is not -1,
174 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
175 is used. @var{mode} is passed directly to <<fopen>> or
178 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
181 The new BFD is marked as cacheable iff @var{fd} is -1.
183 If <<NULL>> is returned then an error has occured. Possible errors
184 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
185 <<system_call>> error.
187 On error, @var{fd} is always closed.
189 A copy of the @var{filename} argument is stored in the newly created
190 BFD. It can be accessed via the bfd_get_filename() macro.
194 bfd_fopen (const char *filename
, const char *target
, const char *mode
, int fd
)
197 const bfd_target
*target_vec
;
199 nbfd
= _bfd_new_bfd ();
207 target_vec
= bfd_find_target (target
, nbfd
);
208 if (target_vec
== NULL
)
212 _bfd_delete_bfd (nbfd
);
218 nbfd
->iostream
= fdopen (fd
, mode
);
221 nbfd
->iostream
= _bfd_real_fopen (filename
, mode
);
222 if (nbfd
->iostream
== NULL
)
224 bfd_set_error (bfd_error_system_call
);
227 _bfd_delete_bfd (nbfd
);
231 /* OK, put everything where it belongs. */
233 /* PR 11983: Do not cache the original filename, but
234 rather make a copy - the original might go away. */
235 nbfd
->filename
= bfd_strdup (filename
);
236 if (nbfd
->filename
== NULL
)
238 fclose (nbfd
->iostream
);
239 _bfd_delete_bfd (nbfd
);
243 /* Figure out whether the user is opening the file for reading,
244 writing, or both, by looking at the MODE argument. */
245 if ((mode
[0] == 'r' || mode
[0] == 'w' || mode
[0] == 'a')
247 nbfd
->direction
= both_direction
;
248 else if (mode
[0] == 'r')
249 nbfd
->direction
= read_direction
;
251 nbfd
->direction
= write_direction
;
253 if (!bfd_cache_init (nbfd
))
255 fclose (nbfd
->iostream
);
256 _bfd_delete_bfd (nbfd
);
259 nbfd
->opened_once
= TRUE
;
261 /* If we opened the file by name, mark it cacheable; we can close it
262 and reopen it later. However, if a file descriptor was provided,
263 then it may have been opened with special flags that make it
264 unsafe to close and reopen the file. */
266 (void) bfd_set_cacheable (nbfd
, TRUE
);
276 bfd *bfd_openr (const char *filename, const char *target);
279 Open the file @var{filename} (using <<fopen>>) with the target
280 @var{target}. Return a pointer to the created BFD.
282 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
285 If <<NULL>> is returned then an error has occured. Possible errors
286 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
287 <<system_call>> error.
289 A copy of the @var{filename} argument is stored in the newly created
290 BFD. It can be accessed via the bfd_get_filename() macro.
294 bfd_openr (const char *filename
, const char *target
)
296 return bfd_fopen (filename
, target
, FOPEN_RB
, -1);
299 /* Don't try to `optimize' this function:
301 o - We lock using stack space so that interrupting the locking
302 won't cause a storage leak.
303 o - We open the file stream last, since we don't want to have to
304 close it if anything goes wrong. Closing the stream means closing
305 the file descriptor too, even though we didn't open it. */
311 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
314 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
315 <<fopen>>. It opens a BFD on a file already described by the
318 When the file is later <<bfd_close>>d, the file descriptor will
319 be closed. If the caller desires that this file descriptor be
320 cached by BFD (opened as needed, closed as needed to free
321 descriptors for other opens), with the supplied @var{fd} used as
322 an initial file descriptor (but subject to closure at any time),
323 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
324 is to assume no caching; the file descriptor will remain open
325 until <<bfd_close>>, and will not be affected by BFD operations
328 Possible errors are <<bfd_error_no_memory>>,
329 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
331 On error, @var{fd} is closed.
333 A copy of the @var{filename} argument is stored in the newly created
334 BFD. It can be accessed via the bfd_get_filename() macro.
338 bfd_fdopenr (const char *filename
, const char *target
, int fd
)
341 #if defined(HAVE_FCNTL) && defined(F_GETFL)
345 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
346 mode
= FOPEN_RUB
; /* Assume full access. */
348 fdflags
= fcntl (fd
, F_GETFL
, NULL
);
355 bfd_set_error (bfd_error_system_call
);
359 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
360 switch (fdflags
& (O_ACCMODE
))
362 case O_RDONLY
: mode
= FOPEN_RB
; break;
363 case O_WRONLY
: mode
= FOPEN_RUB
; break;
364 case O_RDWR
: mode
= FOPEN_RUB
; break;
369 return bfd_fopen (filename
, target
, mode
, fd
);
377 bfd *bfd_openstreamr (const char * filename, const char * target,
381 Open a BFD for read access on an existing stdio stream. When
382 the BFD is passed to <<bfd_close>>, the stream will be closed.
384 A copy of the @var{filename} argument is stored in the newly created
385 BFD. It can be accessed via the bfd_get_filename() macro.
389 bfd_openstreamr (const char *filename
, const char *target
, void *streamarg
)
391 FILE *stream
= (FILE *) streamarg
;
393 const bfd_target
*target_vec
;
395 nbfd
= _bfd_new_bfd ();
399 target_vec
= bfd_find_target (target
, nbfd
);
400 if (target_vec
== NULL
)
402 _bfd_delete_bfd (nbfd
);
406 nbfd
->iostream
= stream
;
407 /* PR 11983: Do not cache the original filename, but
408 rather make a copy - the original might go away. */
409 nbfd
->filename
= bfd_strdup (filename
);
410 if (nbfd
->filename
== NULL
)
412 _bfd_delete_bfd (nbfd
);
415 nbfd
->direction
= read_direction
;
417 if (! bfd_cache_init (nbfd
))
419 _bfd_delete_bfd (nbfd
);
431 bfd *bfd_openr_iovec (const char *filename, const char *target,
432 void *(*open_func) (struct bfd *nbfd,
435 file_ptr (*pread_func) (struct bfd *nbfd,
440 int (*close_func) (struct bfd *nbfd,
442 int (*stat_func) (struct bfd *abfd,
447 Create and return a BFD backed by a read-only @var{stream}.
448 The @var{stream} is created using @var{open_func}, accessed using
449 @var{pread_func} and destroyed using @var{close_func}.
451 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
454 Calls @var{open_func} (which can call <<bfd_zalloc>> and
455 <<bfd_get_filename>>) to obtain the read-only stream backing
456 the BFD. @var{open_func} either succeeds returning the
457 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
458 (setting <<bfd_error>>).
460 Calls @var{pread_func} to request @var{nbytes} of data from
461 @var{stream} starting at @var{offset} (e.g., via a call to
462 <<bfd_read>>). @var{pread_func} either succeeds returning the
463 number of bytes read (which can be less than @var{nbytes} when
464 end-of-file), or fails returning -1 (setting <<bfd_error>>).
466 Calls @var{close_func} when the BFD is later closed using
467 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
468 fails returning -1 (setting <<bfd_error>>).
470 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
471 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
472 on success, or returns -1 on failure (setting <<bfd_error>>).
474 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
475 occurred. Possible errors are <<bfd_error_no_memory>>,
476 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
478 A copy of the @var{filename} argument is stored in the newly created
479 BFD. It can be accessed via the bfd_get_filename() macro.
485 file_ptr (*pread
) (struct bfd
*abfd
, void *stream
, void *buf
,
486 file_ptr nbytes
, file_ptr offset
);
487 int (*close
) (struct bfd
*abfd
, void *stream
);
488 int (*stat
) (struct bfd
*abfd
, void *stream
, struct stat
*sb
);
493 opncls_btell (struct bfd
*abfd
)
495 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
500 opncls_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
502 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
505 case SEEK_SET
: vec
->where
= offset
; break;
506 case SEEK_CUR
: vec
->where
+= offset
; break;
507 case SEEK_END
: return -1;
513 opncls_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
515 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
516 file_ptr nread
= (vec
->pread
) (abfd
, vec
->stream
, buf
, nbytes
, vec
->where
);
525 opncls_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
526 const void *where ATTRIBUTE_UNUSED
,
527 file_ptr nbytes ATTRIBUTE_UNUSED
)
533 opncls_bclose (struct bfd
*abfd
)
535 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
536 /* Since the VEC's memory is bound to the bfd deleting the bfd will
540 if (vec
->close
!= NULL
)
541 status
= (vec
->close
) (abfd
, vec
->stream
);
542 abfd
->iostream
= NULL
;
547 opncls_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
553 opncls_bstat (struct bfd
*abfd
, struct stat
*sb
)
555 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
557 memset (sb
, 0, sizeof (*sb
));
558 if (vec
->stat
== NULL
)
561 return (vec
->stat
) (abfd
, vec
->stream
, sb
);
565 opncls_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
566 void *addr ATTRIBUTE_UNUSED
,
567 bfd_size_type len ATTRIBUTE_UNUSED
,
568 int prot ATTRIBUTE_UNUSED
,
569 int flags ATTRIBUTE_UNUSED
,
570 file_ptr offset ATTRIBUTE_UNUSED
,
571 void **map_addr ATTRIBUTE_UNUSED
,
572 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
577 static const struct bfd_iovec opncls_iovec
=
579 &opncls_bread
, &opncls_bwrite
, &opncls_btell
, &opncls_bseek
,
580 &opncls_bclose
, &opncls_bflush
, &opncls_bstat
, &opncls_bmmap
584 bfd_openr_iovec (const char *filename
, const char *target
,
585 void *(*open_p
) (struct bfd
*, void *),
587 file_ptr (*pread_p
) (struct bfd
*, void *, void *,
589 int (*close_p
) (struct bfd
*, void *),
590 int (*stat_p
) (struct bfd
*, void *, struct stat
*))
593 const bfd_target
*target_vec
;
597 nbfd
= _bfd_new_bfd ();
601 target_vec
= bfd_find_target (target
, nbfd
);
602 if (target_vec
== NULL
)
604 _bfd_delete_bfd (nbfd
);
608 /* PR 11983: Do not cache the original filename, but
609 rather make a copy - the original might go away. */
610 nbfd
->filename
= bfd_strdup (filename
);
611 if (nbfd
->filename
== NULL
)
613 _bfd_delete_bfd (nbfd
);
616 nbfd
->direction
= read_direction
;
618 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
619 stream
= (*open_p
) (nbfd
, open_closure
);
622 _bfd_delete_bfd (nbfd
);
626 vec
= (struct opncls
*) bfd_zalloc (nbfd
, sizeof (struct opncls
));
627 vec
->stream
= stream
;
628 vec
->pread
= pread_p
;
629 vec
->close
= close_p
;
632 nbfd
->iovec
= &opncls_iovec
;
633 nbfd
->iostream
= vec
;
638 /* bfd_openw -- open for writing.
639 Returns a pointer to a freshly-allocated BFD on success, or NULL.
641 See comment by bfd_fdopenr before you try to modify this function. */
648 bfd *bfd_openw (const char *filename, const char *target);
651 Create a BFD, associated with file @var{filename}, using the
652 file format @var{target}, and return a pointer to it.
654 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
655 <<bfd_error_invalid_target>>.
657 A copy of the @var{filename} argument is stored in the newly created
658 BFD. It can be accessed via the bfd_get_filename() macro.
662 bfd_openw (const char *filename
, const char *target
)
665 const bfd_target
*target_vec
;
667 /* nbfd has to point to head of malloc'ed block so that bfd_close may
668 reclaim it correctly. */
669 nbfd
= _bfd_new_bfd ();
673 target_vec
= bfd_find_target (target
, nbfd
);
674 if (target_vec
== NULL
)
676 _bfd_delete_bfd (nbfd
);
680 /* PR 11983: Do not cache the original filename, but
681 rather make a copy - the original might go away. */
682 nbfd
->filename
= bfd_strdup (filename
);
683 if (nbfd
->filename
== NULL
)
685 _bfd_delete_bfd (nbfd
);
688 nbfd
->direction
= write_direction
;
690 if (bfd_open_file (nbfd
) == NULL
)
692 /* File not writeable, etc. */
693 bfd_set_error (bfd_error_system_call
);
694 _bfd_delete_bfd (nbfd
);
702 _maybe_make_executable (bfd
* abfd
)
704 /* If the file was open for writing and is now executable,
706 if (abfd
->direction
== write_direction
707 && (abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
711 if (stat (bfd_get_filename (abfd
), &buf
) == 0
712 /* Do not attempt to change non-regular files. This is
713 here especially for configure scripts and kernel builds
714 which run tests with "ld [...] -o /dev/null". */
715 && S_ISREG(buf
.st_mode
))
717 unsigned int mask
= umask (0);
720 chmod (bfd_get_filename (abfd
),
722 & (buf
.st_mode
| ((S_IXUSR
| S_IXGRP
| S_IXOTH
) &~ mask
))));
732 bfd_boolean bfd_close (bfd *abfd);
735 Close a BFD. If the BFD was open for writing, then pending
736 operations are completed and the file written out and closed.
737 If the created file is executable, then <<chmod>> is called
740 All memory attached to the BFD is released.
742 The file descriptor associated with the BFD is closed (even
743 if it was passed in to BFD by <<bfd_fdopenr>>).
746 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
750 bfd_close (bfd
*abfd
)
752 if (bfd_write_p (abfd
))
754 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
758 return bfd_close_all_done (abfd
);
766 bfd_boolean bfd_close_all_done (bfd *);
769 Close a BFD. Differs from <<bfd_close>> since it does not
770 complete any pending operations. This routine would be used
771 if the application had just used BFD for swapping and didn't
772 want to use any of the writing code.
774 If the created file is executable, then <<chmod>> is called
777 All memory attached to the BFD is released.
780 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
784 bfd_close_all_done (bfd
*abfd
)
788 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
791 ret
= abfd
->iovec
->bclose (abfd
) == 0;
794 _maybe_make_executable (abfd
);
796 _bfd_delete_bfd (abfd
);
806 bfd *bfd_create (const char *filename, bfd *templ);
809 Create a new BFD in the manner of <<bfd_openw>>, but without
810 opening a file. The new BFD takes the target from the target
811 used by @var{templ}. The format is always set to <<bfd_object>>.
813 A copy of the @var{filename} argument is stored in the newly created
814 BFD. It can be accessed via the bfd_get_filename() macro.
818 bfd_create (const char *filename
, bfd
*templ
)
822 nbfd
= _bfd_new_bfd ();
825 /* PR 11983: Do not cache the original filename, but
826 rather make a copy - the original might go away. */
827 nbfd
->filename
= bfd_strdup (filename
);
828 if (nbfd
->filename
== NULL
)
830 _bfd_delete_bfd (nbfd
);
834 nbfd
->xvec
= templ
->xvec
;
835 nbfd
->direction
= no_direction
;
836 bfd_set_format (nbfd
, bfd_object
);
846 bfd_boolean bfd_make_writable (bfd *abfd);
849 Takes a BFD as created by <<bfd_create>> and converts it
850 into one like as returned by <<bfd_openw>>. It does this
851 by converting the BFD to BFD_IN_MEMORY. It's assumed that
852 you will call <<bfd_make_readable>> on this bfd later.
855 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
859 bfd_make_writable (bfd
*abfd
)
861 struct bfd_in_memory
*bim
;
863 if (abfd
->direction
!= no_direction
)
865 bfd_set_error (bfd_error_invalid_operation
);
869 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
871 return FALSE
; /* bfd_error already set. */
872 abfd
->iostream
= bim
;
873 /* bfd_bwrite will grow these as needed. */
877 abfd
->flags
|= BFD_IN_MEMORY
;
878 abfd
->iovec
= &_bfd_memory_iovec
;
880 abfd
->direction
= write_direction
;
891 bfd_boolean bfd_make_readable (bfd *abfd);
894 Takes a BFD as created by <<bfd_create>> and
895 <<bfd_make_writable>> and converts it into one like as
896 returned by <<bfd_openr>>. It does this by writing the
897 contents out to the memory buffer, then reversing the
901 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
904 bfd_make_readable (bfd
*abfd
)
906 if (abfd
->direction
!= write_direction
|| !(abfd
->flags
& BFD_IN_MEMORY
))
908 bfd_set_error (bfd_error_invalid_operation
);
912 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
915 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
918 abfd
->arch_info
= &bfd_default_arch_struct
;
921 abfd
->format
= bfd_unknown
;
922 abfd
->my_archive
= NULL
;
924 abfd
->opened_once
= FALSE
;
925 abfd
->output_has_begun
= FALSE
;
926 abfd
->section_count
= 0;
927 abfd
->usrdata
= NULL
;
928 abfd
->cacheable
= FALSE
;
929 abfd
->flags
|= BFD_IN_MEMORY
;
930 abfd
->mtime_set
= FALSE
;
932 abfd
->target_defaulted
= TRUE
;
933 abfd
->direction
= read_direction
;
936 abfd
->outsymbols
= 0;
939 bfd_section_list_clear (abfd
);
940 bfd_check_format (abfd
, bfd_object
);
950 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
953 Allocate a block of @var{wanted} bytes of memory attached to
954 <<abfd>> and return a pointer to it.
958 bfd_alloc (bfd
*abfd
, bfd_size_type size
)
961 unsigned long ul_size
= (unsigned long) size
;
964 /* Note - although objalloc_alloc takes an unsigned long as its
965 argument, internally the size is treated as a signed long. This can
966 lead to problems where, for example, a request to allocate -1 bytes
967 can result in just 1 byte being allocated, rather than
968 ((unsigned long) -1) bytes. Also memory checkers will often
969 complain about attempts to allocate a negative amount of memory.
970 So to stop these problems we fail if the size is negative. */
971 || ((signed long) ul_size
) < 0)
973 bfd_set_error (bfd_error_no_memory
);
977 ret
= objalloc_alloc ((struct objalloc
*) abfd
->memory
, ul_size
);
979 bfd_set_error (bfd_error_no_memory
);
988 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
991 Allocate a block of @var{wanted} bytes of zeroed memory
992 attached to <<abfd>> and return a pointer to it.
996 bfd_zalloc (bfd
*abfd
, bfd_size_type size
)
1000 res
= bfd_alloc (abfd
, size
);
1002 memset (res
, 0, (size_t) size
);
1006 /* Free a block allocated for a BFD.
1007 Note: Also frees all more recently allocated blocks! */
1010 bfd_release (bfd
*abfd
, void *block
)
1012 objalloc_free_block ((struct objalloc
*) abfd
->memory
, block
);
1017 GNU Extension: separate debug-info files
1019 The idea here is that a special section called .gnu_debuglink might be
1020 embedded in a binary file, which indicates that some *other* file
1021 contains the real debugging information. This special section contains a
1022 filename and CRC32 checksum, which we read and resolve to another file,
1025 This facilitates "optional" provision of debugging information, without
1026 having to provide two complete copies of every binary object (with and
1027 without debug symbols). */
1029 #define GNU_DEBUGLINK ".gnu_debuglink"
1030 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1034 bfd_calc_gnu_debuglink_crc32
1037 unsigned long bfd_calc_gnu_debuglink_crc32
1038 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1041 Computes a CRC value as used in the .gnu_debuglink section.
1042 Advances the previously computed @var{crc} value by computing
1043 and adding in the crc32 for @var{len} bytes of @var{buf}.
1046 Return the updated CRC32 value.
1050 bfd_calc_gnu_debuglink_crc32 (unsigned long crc
,
1051 const unsigned char *buf
,
1054 static const unsigned long crc32_table
[256] =
1056 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1057 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1058 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1059 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1060 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1061 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1062 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1063 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1064 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1065 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1066 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1067 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1068 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1069 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1070 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1071 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1072 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1073 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1074 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1075 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1076 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1077 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1078 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1079 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1080 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1081 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1082 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1083 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1084 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1085 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1086 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1087 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1088 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1089 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1090 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1091 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1092 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1093 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1094 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1095 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1096 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1097 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1098 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1099 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1100 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1101 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1102 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1103 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1104 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1105 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1106 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1109 const unsigned char *end
;
1111 crc
= ~crc
& 0xffffffff;
1112 for (end
= buf
+ len
; buf
< end
; ++ buf
)
1113 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
1114 return ~crc
& 0xffffffff;
1120 bfd_get_debug_link_info_1
1123 char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out);
1126 Extracts the filename and CRC32 value for any separate debug
1127 information file associated with @var{abfd}.
1129 The @var{crc32_out} parameter is an untyped pointer because
1130 this routine is used as a @code{get_func_type} function, but it
1131 is expected to be an unsigned long pointer.
1134 The filename of the associated debug information file, or NULL
1135 if there is no such file. If the filename was found then the
1136 contents of @var{crc32_out} are updated to hold the corresponding
1137 CRC32 value for the file.
1139 The returned filename is allocated with @code{malloc}; freeing
1140 it is the responsibility of the caller.
1144 bfd_get_debug_link_info_1 (bfd
*abfd
, void *crc32_out
)
1147 unsigned long *crc32
= (unsigned long *) crc32_out
;
1149 unsigned int crc_offset
;
1152 ufile_ptr file_size
;
1155 BFD_ASSERT (crc32_out
);
1157 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1162 size
= bfd_section_size (sect
);
1163 file_size
= bfd_get_size (abfd
);
1165 /* PR 22794: Make sure that the section has a reasonable size. */
1166 if (size
< 8 || (file_size
!= 0 && size
>= file_size
))
1169 if (!bfd_malloc_and_get_section (abfd
, sect
, &contents
))
1171 if (contents
!= NULL
)
1176 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1177 name
= (char *) contents
;
1178 /* PR 17597: Avoid reading off the end of the buffer. */
1179 crc_offset
= strnlen (name
, size
) + 1;
1180 crc_offset
= (crc_offset
+ 3) & ~3;
1181 if (crc_offset
+ 4 > size
)
1184 *crc32
= bfd_get_32 (abfd
, contents
+ crc_offset
);
1191 bfd_get_debug_link_info
1194 char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1197 Extracts the filename and CRC32 value for any separate debug
1198 information file associated with @var{abfd}.
1201 The filename of the associated debug information file, or NULL
1202 if there is no such file. If the filename was found then the
1203 contents of @var{crc32_out} are updated to hold the corresponding
1204 CRC32 value for the file.
1206 The returned filename is allocated with @code{malloc}; freeing
1207 it is the responsibility of the caller.
1211 bfd_get_debug_link_info (bfd
*abfd
, unsigned long *crc32_out
)
1213 return bfd_get_debug_link_info_1 (abfd
, crc32_out
);
1218 bfd_get_alt_debug_link_info
1221 char *bfd_get_alt_debug_link_info (bfd * abfd,
1222 bfd_size_type *buildid_len,
1223 bfd_byte **buildid_out);
1226 Fetch the filename and BuildID value for any alternate debuginfo
1227 associated with @var{abfd}. Return NULL if no such info found,
1228 otherwise return filename and update @var{buildid_len} and
1229 @var{buildid_out}. The returned filename and build_id are
1230 allocated with @code{malloc}; freeing them is the responsibility
1235 bfd_get_alt_debug_link_info (bfd
* abfd
, bfd_size_type
*buildid_len
,
1236 bfd_byte
**buildid_out
)
1240 unsigned int buildid_offset
;
1243 ufile_ptr file_size
;
1246 BFD_ASSERT (buildid_len
);
1247 BFD_ASSERT (buildid_out
);
1249 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGALTLINK
);
1254 size
= bfd_section_size (sect
);
1255 file_size
= bfd_get_size (abfd
);
1256 if (size
< 8 || (file_size
!= 0 && size
>= file_size
))
1259 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1261 if (contents
!= NULL
)
1266 /* BuildID value is stored after the filename. */
1267 name
= (char *) contents
;
1268 buildid_offset
= strnlen (name
, size
) + 1;
1269 if (buildid_offset
>= bfd_section_size (sect
))
1272 *buildid_len
= size
- buildid_offset
;
1273 *buildid_out
= bfd_malloc (*buildid_len
);
1274 memcpy (*buildid_out
, contents
+ buildid_offset
, *buildid_len
);
1281 separate_debug_file_exists
1284 bfd_boolean separate_debug_file_exists
1285 (char *name, void *crc32_p);
1288 Checks to see if @var{name} is a file and if its contents
1289 match @var{crc32}, which is a pointer to an @code{unsigned
1290 long} containing a CRC32.
1292 The @var{crc32_p} parameter is an untyped pointer because
1293 this routine is used as a @code{check_func_type} function.
1297 separate_debug_file_exists (const char *name
, void *crc32_p
)
1299 static unsigned char buffer
[8 * 1024];
1300 unsigned long file_crc
= 0;
1302 bfd_size_type count
;
1306 BFD_ASSERT (crc32_p
);
1308 crc
= *(unsigned long *) crc32_p
;
1310 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1314 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
1315 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1319 return crc
== file_crc
;
1324 separate_alt_debug_file_exists
1327 bfd_boolean separate_alt_debug_file_exists
1328 (char *name, void *unused);
1331 Checks to see if @var{name} is a file.
1335 separate_alt_debug_file_exists (const char *name
, void *unused ATTRIBUTE_UNUSED
)
1341 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1352 find_separate_debug_file
1355 char *find_separate_debug_file
1356 (bfd *abfd, const char *dir, bfd_boolean include_dirs,
1357 get_func_type get, check_func_type check, void *data);
1360 Searches for a debug information file corresponding to @var{abfd}.
1362 The name of the separate debug info file is returned by the
1363 @var{get} function. This function scans various fixed locations
1364 in the filesystem, including the file tree rooted at @var{dir}.
1365 If the @var{include_dirs} parameter is true then the directory
1366 components of @var{abfd}'s filename will be included in the
1369 @var{data} is passed unmodified to the @var{get} and @var{check}
1370 functions. It is generally used to implement build-id-like
1371 matching in the callback functions.
1374 Returns the filename of the first file to be found which
1375 receives a TRUE result from the @var{check} function.
1376 Returns NULL if no valid file could be found.
1379 typedef char * (* get_func_type
) (bfd
*, void *);
1380 typedef bfd_boolean (* check_func_type
) (const char *, void *);
1383 find_separate_debug_file (bfd
* abfd
,
1384 const char * debug_file_directory
,
1385 bfd_boolean include_dirs
,
1386 get_func_type get_func
,
1387 check_func_type check_func
,
1395 size_t canon_dirlen
;
1398 if (debug_file_directory
== NULL
)
1399 debug_file_directory
= ".";
1401 /* BFD may have been opened from a stream. */
1402 if (bfd_get_filename (abfd
) == NULL
)
1404 bfd_set_error (bfd_error_invalid_operation
);
1408 base
= get_func (abfd
, func_data
);
1413 if (base
[0] == '\0')
1416 bfd_set_error (bfd_error_no_debug_section
);
1422 const char *fname
= bfd_get_filename (abfd
);
1423 for (dirlen
= strlen (fname
); dirlen
> 0; dirlen
--)
1424 if (IS_DIR_SEPARATOR (fname
[dirlen
- 1]))
1427 dir
= (char *) bfd_malloc (dirlen
+ 1);
1433 memcpy (dir
, fname
, dirlen
);
1438 dir
= (char *) bfd_malloc (1);
1443 /* Compute the canonical name of the bfd object with all symbolic links
1444 resolved, for use in the global debugfile directory. */
1445 canon_dir
= lrealpath (bfd_get_filename (abfd
));
1446 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
1447 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
1449 canon_dir
[canon_dirlen
] = '\0';
1451 #ifndef EXTRA_DEBUG_ROOT1
1452 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1454 #ifndef EXTRA_DEBUG_ROOT2
1455 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1458 debugfile
= (char *)
1459 bfd_malloc (strlen (debug_file_directory
) + 1
1460 + (canon_dirlen
> dirlen
? canon_dirlen
: dirlen
)
1461 + strlen (".debug/")
1462 #ifdef EXTRA_DEBUG_ROOT1
1463 + strlen (EXTRA_DEBUG_ROOT1
)
1465 #ifdef EXTRA_DEBUG_ROOT2
1466 + strlen (EXTRA_DEBUG_ROOT2
)
1470 if (debugfile
== NULL
)
1471 goto found
; /* Actually this returns NULL. */
1473 /* First try in the same directory as the original file.
1475 FIXME: Strictly speaking if we are using the build-id method,
1476 (ie include_dirs == FALSE) then we should only check absolute
1477 paths, not relative ones like this one (and the next one).
1478 The check is left in however as this allows the binutils
1479 testsuite to exercise this feature without having to install
1480 a file into the root filesystem. (See binutils/testsuite/
1481 binutils-all/objdump.exp for the test). */
1482 sprintf (debugfile
, "%s%s", dir
, base
);
1483 if (check_func (debugfile
, func_data
))
1486 /* Then try in a subdirectory called .debug. */
1487 sprintf (debugfile
, "%s.debug/%s", dir
, base
);
1488 if (check_func (debugfile
, func_data
))
1491 #ifdef EXTRA_DEBUG_ROOT1
1492 /* Try the first extra debug file root. */
1493 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT1
,
1494 include_dirs
? canon_dir
: "/", base
);
1495 if (check_func (debugfile
, func_data
))
1499 #ifdef EXTRA_DEBUG_ROOT2
1500 /* Try the second extra debug file root. */
1501 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT2
,
1502 include_dirs
? canon_dir
: "/", base
);
1503 if (check_func (debugfile
, func_data
))
1507 /* Then try in the global debugfile directory. */
1508 strcpy (debugfile
, debug_file_directory
);
1509 dirlen
= strlen (debug_file_directory
) - 1;
1513 && debug_file_directory
[dirlen
] != '/'
1514 && canon_dir
[0] != '/')
1515 strcat (debugfile
, "/");
1516 strcat (debugfile
, canon_dir
);
1520 if (dirlen
> 0 && debug_file_directory
[dirlen
] != '/')
1521 strcat (debugfile
, "/");
1523 strcat (debugfile
, base
);
1525 if (check_func (debugfile
, func_data
))
1528 /* Failed to find the file. */
1541 bfd_follow_gnu_debuglink
1544 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1547 Takes a BFD and searches it for a .gnu_debuglink section. If this
1548 section is found, it examines the section for the name and checksum
1549 of a '.debug' file containing auxiliary debugging information. It
1550 then searches the filesystem for this .debug file in some standard
1551 locations, including the directory tree rooted at @var{dir}, and if
1552 found returns the full filename.
1554 If @var{dir} is NULL, the search will take place starting at
1555 the current directory.
1558 <<NULL>> on any errors or failure to locate the .debug file,
1559 otherwise a pointer to a heap-allocated string containing the
1560 filename. The caller is responsible for freeing this string.
1564 bfd_follow_gnu_debuglink (bfd
*abfd
, const char *dir
)
1566 unsigned long crc32
;
1568 return find_separate_debug_file (abfd
, dir
, TRUE
,
1569 bfd_get_debug_link_info_1
,
1570 separate_debug_file_exists
, &crc32
);
1573 /* Helper for bfd_follow_gnu_debugaltlink. It just returns the name
1574 of the separate debug file. */
1577 get_alt_debug_link_info_shim (bfd
* abfd
, void *unused ATTRIBUTE_UNUSED
)
1580 bfd_byte
*buildid
= NULL
;
1581 char *result
= bfd_get_alt_debug_link_info (abfd
, &len
, &buildid
);
1590 bfd_follow_gnu_debugaltlink
1593 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1596 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1597 section is found, it examines the section for the name of a file
1598 containing auxiliary debugging information. It then searches the
1599 filesystem for this file in a set of standard locations, including
1600 the directory tree rooted at @var{dir}, and if found returns the
1603 If @var{dir} is NULL, the search will take place starting at
1604 the current directory.
1607 <<NULL>> on any errors or failure to locate the debug file,
1608 otherwise a pointer to a heap-allocated string containing the
1609 filename. The caller is responsible for freeing this string.
1613 bfd_follow_gnu_debugaltlink (bfd
*abfd
, const char *dir
)
1615 return find_separate_debug_file (abfd
, dir
, TRUE
,
1616 get_alt_debug_link_info_shim
,
1617 separate_alt_debug_file_exists
,
1623 bfd_create_gnu_debuglink_section
1626 struct bfd_section *bfd_create_gnu_debuglink_section
1627 (bfd *abfd, const char *filename);
1630 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The
1631 section is sized to be big enough to contain a link to the specified
1635 A pointer to the new section is returned if all is ok. Otherwise
1636 <<NULL>> is returned and bfd_error is set.
1640 bfd_create_gnu_debuglink_section (bfd
*abfd
, const char *filename
)
1643 bfd_size_type debuglink_size
;
1646 if (abfd
== NULL
|| filename
== NULL
)
1648 bfd_set_error (bfd_error_invalid_operation
);
1652 /* Strip off any path components in filename. */
1653 filename
= lbasename (filename
);
1655 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1658 /* Section already exists. */
1659 bfd_set_error (bfd_error_invalid_operation
);
1663 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DEBUGGING
;
1664 sect
= bfd_make_section_with_flags (abfd
, GNU_DEBUGLINK
, flags
);
1668 /* Compute the size of the section. Allow for the CRC after the filename,
1669 and padding so that it will start on a 4-byte boundary. */
1670 debuglink_size
= strlen (filename
) + 1;
1671 debuglink_size
+= 3;
1672 debuglink_size
&= ~3;
1673 debuglink_size
+= 4;
1675 if (!bfd_set_section_size (sect
, debuglink_size
))
1676 /* XXX Should we delete the section from the bfd ? */
1679 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1680 Note - despite the name of the function being called, we are
1681 setting an alignment power, not a byte alignment value. */
1682 bfd_set_section_alignment (sect
, 2);
1690 bfd_fill_in_gnu_debuglink_section
1693 bfd_boolean bfd_fill_in_gnu_debuglink_section
1694 (bfd *abfd, struct bfd_section *sect, const char *filename);
1697 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1698 and fills in the contents of the section to contain a link to the
1699 specified @var{filename}. The filename should be relative to the
1703 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1704 and bfd_error is set.
1708 bfd_fill_in_gnu_debuglink_section (bfd
*abfd
,
1709 struct bfd_section
*sect
,
1710 const char *filename
)
1712 bfd_size_type debuglink_size
;
1713 unsigned long crc32
;
1715 bfd_size_type crc_offset
;
1717 static unsigned char buffer
[8 * 1024];
1721 if (abfd
== NULL
|| sect
== NULL
|| filename
== NULL
)
1723 bfd_set_error (bfd_error_invalid_operation
);
1727 /* Make sure that we can read the file.
1728 XXX - Should we attempt to locate the debug info file using the same
1729 algorithm as gdb ? At the moment, since we are creating the
1730 .gnu_debuglink section, we insist upon the user providing us with a
1731 correct-for-section-creation-time path, but this need not conform to
1732 the gdb location algorithm. */
1733 handle
= _bfd_real_fopen (filename
, FOPEN_RB
);
1736 bfd_set_error (bfd_error_system_call
);
1741 while ((count
= fread (buffer
, 1, sizeof buffer
, handle
)) > 0)
1742 crc32
= bfd_calc_gnu_debuglink_crc32 (crc32
, buffer
, count
);
1745 /* Strip off any path components in filename,
1746 now that we no longer need them. */
1747 filename
= lbasename (filename
);
1749 filelen
= strlen (filename
);
1750 debuglink_size
= filelen
+ 1;
1751 debuglink_size
+= 3;
1752 debuglink_size
&= ~3;
1753 debuglink_size
+= 4;
1755 contents
= (char *) bfd_malloc (debuglink_size
);
1756 if (contents
== NULL
)
1758 /* XXX Should we delete the section from the bfd ? */
1762 crc_offset
= debuglink_size
- 4;
1763 memcpy (contents
, filename
, filelen
);
1764 memset (contents
+ filelen
, 0, crc_offset
- filelen
);
1766 bfd_put_32 (abfd
, crc32
, contents
+ crc_offset
);
1768 if (! bfd_set_section_contents (abfd
, sect
, contents
, 0, debuglink_size
))
1770 /* XXX Should we delete the section from the bfd ? */
1783 struct bfd_build_id * get_build_id (bfd *abfd);
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}.
1792 Returns a pointer to the build-id structure if a build-id could be
1793 found. If no build-id is found NULL is returned and error code is
1797 static struct bfd_build_id
*
1798 get_build_id (bfd
*abfd
)
1800 struct bfd_build_id
*build_id
;
1801 Elf_Internal_Note inote
;
1802 Elf_External_Note
*enote
;
1809 if (abfd
->build_id
&& abfd
->build_id
->size
> 0)
1810 /* Save some time by using the already computed build-id. */
1811 return (struct bfd_build_id
*) abfd
->build_id
;
1813 sect
= bfd_get_section_by_name (abfd
, ".note.gnu.build-id");
1816 bfd_set_error (bfd_error_no_debug_section
);
1820 size
= bfd_section_size (sect
);
1821 /* FIXME: Should we support smaller build-id notes ? */
1824 bfd_set_error (bfd_error_invalid_operation
);
1828 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1830 if (contents
!= NULL
)
1835 /* FIXME: Paranoia - allow for compressed build-id sections.
1836 Maybe we should complain if this size is different from
1837 the one obtained above... */
1838 size
= bfd_section_size (sect
);
1839 if (size
< sizeof (Elf_External_Note
))
1841 bfd_set_error (bfd_error_invalid_operation
);
1846 enote
= (Elf_External_Note
*) contents
;
1847 inote
.type
= H_GET_32 (abfd
, enote
->type
);
1848 inote
.namesz
= H_GET_32 (abfd
, enote
->namesz
);
1849 inote
.namedata
= enote
->name
;
1850 inote
.descsz
= H_GET_32 (abfd
, enote
->descsz
);
1851 inote
.descdata
= inote
.namedata
+ BFD_ALIGN (inote
.namesz
, 4);
1852 /* FIXME: Should we check for extra notes in this section ? */
1854 if (inote
.descsz
<= 0
1855 || inote
.type
!= NT_GNU_BUILD_ID
1856 || inote
.namesz
!= 4 /* sizeof "GNU" */
1857 || strncmp (inote
.namedata
, "GNU", 4) != 0
1858 || inote
.descsz
> 0x7ffffffe
1859 || size
< (12 + BFD_ALIGN (inote
.namesz
, 4) + inote
.descsz
))
1862 bfd_set_error (bfd_error_invalid_operation
);
1866 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) + inote
.descsz
);
1867 if (build_id
== NULL
)
1873 build_id
->size
= inote
.descsz
;
1874 memcpy (build_id
->data
, inote
.descdata
, inote
.descsz
);
1875 abfd
->build_id
= build_id
;
1886 char * get_build_id_name (bfd *abfd, void *build_id_out_p)
1889 Searches @var{abfd} for a build-id, and then constructs a pathname
1890 from it. The path is computed as .build-id/NN/NN+NN.debug where
1891 NNNN+NN is the build-id value as a hexadecimal string.
1894 Returns the constructed filename or NULL upon error.
1895 It is the caller's responsibility to free the memory used to hold the
1897 If a filename is returned then the @var{build_id_out_p}
1898 parameter (which points to a @code{struct bfd_build_id}
1899 pointer) is set to a pointer to the build_id structure.
1903 get_build_id_name (bfd
*abfd
, void *build_id_out_p
)
1905 struct bfd_build_id
**build_id_out
= build_id_out_p
;
1906 struct bfd_build_id
*build_id
;
1912 if (abfd
== NULL
|| bfd_get_filename (abfd
) == NULL
|| build_id_out
== NULL
)
1914 bfd_set_error (bfd_error_invalid_operation
);
1918 build_id
= get_build_id (abfd
);
1919 if (build_id
== NULL
)
1922 /* Compute the debug pathname corresponding to the build-id. */
1923 name
= bfd_malloc (strlen (".build-id/") + build_id
->size
* 2 + 2 + strlen (".debug"));
1926 bfd_set_error (bfd_error_no_memory
);
1933 n
+= sprintf (n
, ".build-id/");
1934 n
+= sprintf (n
, "%02x", (unsigned) *d
++); s
--;
1935 n
+= sprintf (n
, "/");
1937 n
+= sprintf (n
, "%02x", (unsigned) *d
++);
1938 n
+= sprintf (n
, ".debug");
1940 *build_id_out
= build_id
;
1949 bfd_boolean check_build_id_file (char *name, void *buildid_p);
1952 Checks to see if @var{name} is a readable file and if its build-id
1953 matches @var{buildid}.
1956 Returns TRUE if the file exists, is readable, and contains a
1957 build-id which matches the build-id pointed at by
1958 @var{build_id_p} (which is really a @code{struct bfd_build_id **}).
1962 check_build_id_file (const char *name
, void *buildid_p
)
1964 struct bfd_build_id
*orig_build_id
;
1965 struct bfd_build_id
*build_id
;
1970 BFD_ASSERT (buildid_p
);
1972 file
= bfd_openr (name
, NULL
);
1976 /* If the file is an archive, process all of its elements. */
1977 if (! bfd_check_format (file
, bfd_object
))
1983 build_id
= get_build_id (file
);
1984 if (build_id
== NULL
)
1990 orig_build_id
= *(struct bfd_build_id
**) buildid_p
;
1992 result
= build_id
->size
== orig_build_id
->size
1993 && memcmp (build_id
->data
, orig_build_id
->data
, build_id
->size
) == 0;
1995 (void) bfd_close (file
);
2002 bfd_follow_build_id_debuglink
2005 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
2008 Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2009 If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2010 note, which should be a hexadecimal value @var{NNNN+NN} (for
2011 32+ hex digits). It then searches the filesystem for a file named
2012 @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2013 including the directory tree rooted at @var{dir}. The filename
2014 of the first matching file to be found is returned. A matching
2015 file should contain a .note.gnu.build-id section with the same
2016 @var{NNNN+NN} note as @var{abfd}, although this check is currently
2019 If @var{dir} is NULL, the search will take place starting at
2020 the current directory.
2023 <<NULL>> on any errors or failure to locate the debug file,
2024 otherwise a pointer to a heap-allocated string containing the
2025 filename. The caller is responsible for freeing this string.
2029 bfd_follow_build_id_debuglink (bfd
*abfd
, const char *dir
)
2031 struct bfd_build_id
*build_id
;
2033 return find_separate_debug_file (abfd
, dir
, FALSE
,
2035 check_build_id_file
, &build_id
);
2043 void bfd_set_filename (bfd *abfd, char *filename);
2046 Set the filename of @var{abfd}. The old filename, if any, is freed.
2047 @var{filename} must be allocated using @code{xmalloc}. After
2048 this call, it is owned @var{abfd}.
2052 bfd_set_filename (bfd
*abfd
, char *filename
)
2054 free ((char *) abfd
->filename
);
2055 abfd
->filename
= filename
;