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
);
130 free ((char *) abfd
->filename
);
131 free (abfd
->arelt_data
);
135 /* Free objalloc memory. */
138 _bfd_free_cached_info (bfd
*abfd
)
142 bfd_hash_table_free (&abfd
->section_htab
);
143 objalloc_free ((struct objalloc
*) abfd
->memory
);
145 abfd
->sections
= NULL
;
146 abfd
->section_last
= NULL
;
147 abfd
->outsymbols
= NULL
;
148 abfd
->tdata
.any
= NULL
;
149 abfd
->usrdata
= NULL
;
158 Opening and closing BFDs
161 Functions for opening and closing
169 bfd *bfd_fopen (const char *filename, const char *target,
170 const char *mode, int fd);
173 Open the file @var{filename} with the target @var{target}.
174 Return a pointer to the created BFD. If @var{fd} is not -1,
175 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
176 is used. @var{mode} is passed directly to <<fopen>> or
179 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
182 The new BFD is marked as cacheable iff @var{fd} is -1.
184 If <<NULL>> is returned then an error has occured. Possible errors
185 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
186 <<system_call>> error.
188 On error, @var{fd} is always closed.
190 A copy of the @var{filename} argument is stored in the newly created
191 BFD. It can be accessed via the bfd_get_filename() macro.
195 bfd_fopen (const char *filename
, const char *target
, const char *mode
, int fd
)
198 const bfd_target
*target_vec
;
200 nbfd
= _bfd_new_bfd ();
208 target_vec
= bfd_find_target (target
, nbfd
);
209 if (target_vec
== NULL
)
213 _bfd_delete_bfd (nbfd
);
219 nbfd
->iostream
= fdopen (fd
, mode
);
222 nbfd
->iostream
= _bfd_real_fopen (filename
, mode
);
223 if (nbfd
->iostream
== NULL
)
225 bfd_set_error (bfd_error_system_call
);
228 _bfd_delete_bfd (nbfd
);
232 /* OK, put everything where it belongs. */
234 /* PR 11983: Do not cache the original filename, but
235 rather make a copy - the original might go away. */
236 nbfd
->filename
= bfd_strdup (filename
);
237 if (nbfd
->filename
== NULL
)
239 fclose (nbfd
->iostream
);
240 _bfd_delete_bfd (nbfd
);
244 /* Figure out whether the user is opening the file for reading,
245 writing, or both, by looking at the MODE argument. */
246 if ((mode
[0] == 'r' || mode
[0] == 'w' || mode
[0] == 'a')
248 nbfd
->direction
= both_direction
;
249 else if (mode
[0] == 'r')
250 nbfd
->direction
= read_direction
;
252 nbfd
->direction
= write_direction
;
254 if (!bfd_cache_init (nbfd
))
256 fclose (nbfd
->iostream
);
257 _bfd_delete_bfd (nbfd
);
260 nbfd
->opened_once
= TRUE
;
262 /* If we opened the file by name, mark it cacheable; we can close it
263 and reopen it later. However, if a file descriptor was provided,
264 then it may have been opened with special flags that make it
265 unsafe to close and reopen the file. */
267 (void) bfd_set_cacheable (nbfd
, TRUE
);
277 bfd *bfd_openr (const char *filename, const char *target);
280 Open the file @var{filename} (using <<fopen>>) with the target
281 @var{target}. Return a pointer to the created BFD.
283 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
286 If <<NULL>> is returned then an error has occured. Possible errors
287 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
288 <<system_call>> error.
290 A copy of the @var{filename} argument is stored in the newly created
291 BFD. It can be accessed via the bfd_get_filename() macro.
295 bfd_openr (const char *filename
, const char *target
)
297 return bfd_fopen (filename
, target
, FOPEN_RB
, -1);
300 /* Don't try to `optimize' this function:
302 o - We lock using stack space so that interrupting the locking
303 won't cause a storage leak.
304 o - We open the file stream last, since we don't want to have to
305 close it if anything goes wrong. Closing the stream means closing
306 the file descriptor too, even though we didn't open it. */
312 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
315 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
316 <<fopen>>. It opens a BFD on a file already described by the
319 When the file is later <<bfd_close>>d, the file descriptor will
320 be closed. If the caller desires that this file descriptor be
321 cached by BFD (opened as needed, closed as needed to free
322 descriptors for other opens), with the supplied @var{fd} used as
323 an initial file descriptor (but subject to closure at any time),
324 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
325 is to assume no caching; the file descriptor will remain open
326 until <<bfd_close>>, and will not be affected by BFD operations
329 Possible errors are <<bfd_error_no_memory>>,
330 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
332 On error, @var{fd} is closed.
334 A copy of the @var{filename} argument is stored in the newly created
335 BFD. It can be accessed via the bfd_get_filename() macro.
339 bfd_fdopenr (const char *filename
, const char *target
, int fd
)
342 #if defined(HAVE_FCNTL) && defined(F_GETFL)
346 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
347 mode
= FOPEN_RUB
; /* Assume full access. */
349 fdflags
= fcntl (fd
, F_GETFL
, NULL
);
356 bfd_set_error (bfd_error_system_call
);
360 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
361 switch (fdflags
& (O_ACCMODE
))
363 case O_RDONLY
: mode
= FOPEN_RB
; break;
364 case O_WRONLY
: mode
= FOPEN_RUB
; break;
365 case O_RDWR
: mode
= FOPEN_RUB
; break;
370 return bfd_fopen (filename
, target
, mode
, fd
);
378 bfd *bfd_openstreamr (const char * filename, const char * target,
382 Open a BFD for read access on an existing stdio stream. When
383 the BFD is passed to <<bfd_close>>, the stream will be closed.
385 A copy of the @var{filename} argument is stored in the newly created
386 BFD. It can be accessed via the bfd_get_filename() macro.
390 bfd_openstreamr (const char *filename
, const char *target
, void *streamarg
)
392 FILE *stream
= (FILE *) streamarg
;
394 const bfd_target
*target_vec
;
396 nbfd
= _bfd_new_bfd ();
400 target_vec
= bfd_find_target (target
, nbfd
);
401 if (target_vec
== NULL
)
403 _bfd_delete_bfd (nbfd
);
407 nbfd
->iostream
= stream
;
408 /* PR 11983: Do not cache the original filename, but
409 rather make a copy - the original might go away. */
410 nbfd
->filename
= bfd_strdup (filename
);
411 if (nbfd
->filename
== NULL
)
413 _bfd_delete_bfd (nbfd
);
416 nbfd
->direction
= read_direction
;
418 if (! bfd_cache_init (nbfd
))
420 _bfd_delete_bfd (nbfd
);
432 bfd *bfd_openr_iovec (const char *filename, const char *target,
433 void *(*open_func) (struct bfd *nbfd,
436 file_ptr (*pread_func) (struct bfd *nbfd,
441 int (*close_func) (struct bfd *nbfd,
443 int (*stat_func) (struct bfd *abfd,
448 Create and return a BFD backed by a read-only @var{stream}.
449 The @var{stream} is created using @var{open_func}, accessed using
450 @var{pread_func} and destroyed using @var{close_func}.
452 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
455 Calls @var{open_func} (which can call <<bfd_zalloc>> and
456 <<bfd_get_filename>>) to obtain the read-only stream backing
457 the BFD. @var{open_func} either succeeds returning the
458 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
459 (setting <<bfd_error>>).
461 Calls @var{pread_func} to request @var{nbytes} of data from
462 @var{stream} starting at @var{offset} (e.g., via a call to
463 <<bfd_read>>). @var{pread_func} either succeeds returning the
464 number of bytes read (which can be less than @var{nbytes} when
465 end-of-file), or fails returning -1 (setting <<bfd_error>>).
467 Calls @var{close_func} when the BFD is later closed using
468 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
469 fails returning -1 (setting <<bfd_error>>).
471 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
472 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
473 on success, or returns -1 on failure (setting <<bfd_error>>).
475 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
476 occurred. Possible errors are <<bfd_error_no_memory>>,
477 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
479 A copy of the @var{filename} argument is stored in the newly created
480 BFD. It can be accessed via the bfd_get_filename() macro.
486 file_ptr (*pread
) (struct bfd
*abfd
, void *stream
, void *buf
,
487 file_ptr nbytes
, file_ptr offset
);
488 int (*close
) (struct bfd
*abfd
, void *stream
);
489 int (*stat
) (struct bfd
*abfd
, void *stream
, struct stat
*sb
);
494 opncls_btell (struct bfd
*abfd
)
496 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
501 opncls_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
503 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
506 case SEEK_SET
: vec
->where
= offset
; break;
507 case SEEK_CUR
: vec
->where
+= offset
; break;
508 case SEEK_END
: return -1;
514 opncls_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
516 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
517 file_ptr nread
= (vec
->pread
) (abfd
, vec
->stream
, buf
, nbytes
, vec
->where
);
526 opncls_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
527 const void *where ATTRIBUTE_UNUSED
,
528 file_ptr nbytes ATTRIBUTE_UNUSED
)
534 opncls_bclose (struct bfd
*abfd
)
536 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
537 /* Since the VEC's memory is bound to the bfd deleting the bfd will
541 if (vec
->close
!= NULL
)
542 status
= (vec
->close
) (abfd
, vec
->stream
);
543 abfd
->iostream
= NULL
;
548 opncls_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
554 opncls_bstat (struct bfd
*abfd
, struct stat
*sb
)
556 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
558 memset (sb
, 0, sizeof (*sb
));
559 if (vec
->stat
== NULL
)
562 return (vec
->stat
) (abfd
, vec
->stream
, sb
);
566 opncls_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
567 void *addr ATTRIBUTE_UNUSED
,
568 bfd_size_type len ATTRIBUTE_UNUSED
,
569 int prot ATTRIBUTE_UNUSED
,
570 int flags ATTRIBUTE_UNUSED
,
571 file_ptr offset ATTRIBUTE_UNUSED
,
572 void **map_addr ATTRIBUTE_UNUSED
,
573 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
578 static const struct bfd_iovec opncls_iovec
=
580 &opncls_bread
, &opncls_bwrite
, &opncls_btell
, &opncls_bseek
,
581 &opncls_bclose
, &opncls_bflush
, &opncls_bstat
, &opncls_bmmap
585 bfd_openr_iovec (const char *filename
, const char *target
,
586 void *(*open_p
) (struct bfd
*, void *),
588 file_ptr (*pread_p
) (struct bfd
*, void *, void *,
590 int (*close_p
) (struct bfd
*, void *),
591 int (*stat_p
) (struct bfd
*, void *, struct stat
*))
594 const bfd_target
*target_vec
;
598 nbfd
= _bfd_new_bfd ();
602 target_vec
= bfd_find_target (target
, nbfd
);
603 if (target_vec
== NULL
)
605 _bfd_delete_bfd (nbfd
);
609 /* PR 11983: Do not cache the original filename, but
610 rather make a copy - the original might go away. */
611 nbfd
->filename
= bfd_strdup (filename
);
612 if (nbfd
->filename
== NULL
)
614 _bfd_delete_bfd (nbfd
);
617 nbfd
->direction
= read_direction
;
619 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
620 stream
= (*open_p
) (nbfd
, open_closure
);
623 _bfd_delete_bfd (nbfd
);
627 vec
= (struct opncls
*) bfd_zalloc (nbfd
, sizeof (struct opncls
));
628 vec
->stream
= stream
;
629 vec
->pread
= pread_p
;
630 vec
->close
= close_p
;
633 nbfd
->iovec
= &opncls_iovec
;
634 nbfd
->iostream
= vec
;
639 /* bfd_openw -- open for writing.
640 Returns a pointer to a freshly-allocated BFD on success, or NULL.
642 See comment by bfd_fdopenr before you try to modify this function. */
649 bfd *bfd_openw (const char *filename, const char *target);
652 Create a BFD, associated with file @var{filename}, using the
653 file format @var{target}, and return a pointer to it.
655 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
656 <<bfd_error_invalid_target>>.
658 A copy of the @var{filename} argument is stored in the newly created
659 BFD. It can be accessed via the bfd_get_filename() macro.
663 bfd_openw (const char *filename
, const char *target
)
666 const bfd_target
*target_vec
;
668 /* nbfd has to point to head of malloc'ed block so that bfd_close may
669 reclaim it correctly. */
670 nbfd
= _bfd_new_bfd ();
674 target_vec
= bfd_find_target (target
, nbfd
);
675 if (target_vec
== NULL
)
677 _bfd_delete_bfd (nbfd
);
681 /* PR 11983: Do not cache the original filename, but
682 rather make a copy - the original might go away. */
683 nbfd
->filename
= bfd_strdup (filename
);
684 if (nbfd
->filename
== NULL
)
686 _bfd_delete_bfd (nbfd
);
689 nbfd
->direction
= write_direction
;
691 if (bfd_open_file (nbfd
) == NULL
)
693 /* File not writeable, etc. */
694 bfd_set_error (bfd_error_system_call
);
695 _bfd_delete_bfd (nbfd
);
703 _maybe_make_executable (bfd
* abfd
)
705 /* If the file was open for writing and is now executable,
707 if (abfd
->direction
== write_direction
708 && (abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
712 if (stat (abfd
->filename
, &buf
) == 0
713 /* Do not attempt to change non-regular files. This is
714 here especially for configure scripts and kernel builds
715 which run tests with "ld [...] -o /dev/null". */
716 && S_ISREG(buf
.st_mode
))
718 unsigned int mask
= umask (0);
721 chmod (abfd
->filename
,
723 & (buf
.st_mode
| ((S_IXUSR
| S_IXGRP
| S_IXOTH
) &~ mask
))));
733 bfd_boolean bfd_close (bfd *abfd);
736 Close a BFD. If the BFD was open for writing, then pending
737 operations are completed and the file written out and closed.
738 If the created file is executable, then <<chmod>> is called
741 All memory attached to the BFD is released.
743 The file descriptor associated with the BFD is closed (even
744 if it was passed in to BFD by <<bfd_fdopenr>>).
747 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
751 bfd_close (bfd
*abfd
)
753 if (bfd_write_p (abfd
))
755 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
759 return bfd_close_all_done (abfd
);
767 bfd_boolean bfd_close_all_done (bfd *);
770 Close a BFD. Differs from <<bfd_close>> since it does not
771 complete any pending operations. This routine would be used
772 if the application had just used BFD for swapping and didn't
773 want to use any of the writing code.
775 If the created file is executable, then <<chmod>> is called
778 All memory attached to the BFD is released.
781 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
785 bfd_close_all_done (bfd
*abfd
)
789 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
792 ret
= abfd
->iovec
->bclose (abfd
) == 0;
795 _maybe_make_executable (abfd
);
797 _bfd_delete_bfd (abfd
);
807 bfd *bfd_create (const char *filename, bfd *templ);
810 Create a new BFD in the manner of <<bfd_openw>>, but without
811 opening a file. The new BFD takes the target from the target
812 used by @var{templ}. The format is always set to <<bfd_object>>.
814 A copy of the @var{filename} argument is stored in the newly created
815 BFD. It can be accessed via the bfd_get_filename() macro.
819 bfd_create (const char *filename
, bfd
*templ
)
823 nbfd
= _bfd_new_bfd ();
826 /* PR 11983: Do not cache the original filename, but
827 rather make a copy - the original might go away. */
828 nbfd
->filename
= bfd_strdup (filename
);
829 if (nbfd
->filename
== NULL
)
831 _bfd_delete_bfd (nbfd
);
835 nbfd
->xvec
= templ
->xvec
;
836 nbfd
->direction
= no_direction
;
837 bfd_set_format (nbfd
, bfd_object
);
847 bfd_boolean bfd_make_writable (bfd *abfd);
850 Takes a BFD as created by <<bfd_create>> and converts it
851 into one like as returned by <<bfd_openw>>. It does this
852 by converting the BFD to BFD_IN_MEMORY. It's assumed that
853 you will call <<bfd_make_readable>> on this bfd later.
856 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
860 bfd_make_writable (bfd
*abfd
)
862 struct bfd_in_memory
*bim
;
864 if (abfd
->direction
!= no_direction
)
866 bfd_set_error (bfd_error_invalid_operation
);
870 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
872 return FALSE
; /* bfd_error already set. */
873 abfd
->iostream
= bim
;
874 /* bfd_bwrite will grow these as needed. */
878 abfd
->flags
|= BFD_IN_MEMORY
;
879 abfd
->iovec
= &_bfd_memory_iovec
;
881 abfd
->direction
= write_direction
;
892 bfd_boolean bfd_make_readable (bfd *abfd);
895 Takes a BFD as created by <<bfd_create>> and
896 <<bfd_make_writable>> and converts it into one like as
897 returned by <<bfd_openr>>. It does this by writing the
898 contents out to the memory buffer, then reversing the
902 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
905 bfd_make_readable (bfd
*abfd
)
907 if (abfd
->direction
!= write_direction
|| !(abfd
->flags
& BFD_IN_MEMORY
))
909 bfd_set_error (bfd_error_invalid_operation
);
913 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
916 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
919 abfd
->arch_info
= &bfd_default_arch_struct
;
922 abfd
->format
= bfd_unknown
;
923 abfd
->my_archive
= NULL
;
925 abfd
->opened_once
= FALSE
;
926 abfd
->output_has_begun
= FALSE
;
927 abfd
->section_count
= 0;
928 abfd
->usrdata
= NULL
;
929 abfd
->cacheable
= FALSE
;
930 abfd
->flags
|= BFD_IN_MEMORY
;
931 abfd
->mtime_set
= FALSE
;
933 abfd
->target_defaulted
= TRUE
;
934 abfd
->direction
= read_direction
;
937 abfd
->outsymbols
= 0;
940 bfd_section_list_clear (abfd
);
941 bfd_check_format (abfd
, bfd_object
);
951 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
954 Allocate a block of @var{wanted} bytes of memory attached to
955 <<abfd>> and return a pointer to it.
959 bfd_alloc (bfd
*abfd
, bfd_size_type size
)
962 unsigned long ul_size
= (unsigned long) size
;
965 /* Note - although objalloc_alloc takes an unsigned long as its
966 argument, internally the size is treated as a signed long. This can
967 lead to problems where, for example, a request to allocate -1 bytes
968 can result in just 1 byte being allocated, rather than
969 ((unsigned long) -1) bytes. Also memory checkers will often
970 complain about attempts to allocate a negative amount of memory.
971 So to stop these problems we fail if the size is negative. */
972 || ((signed long) ul_size
) < 0)
974 bfd_set_error (bfd_error_no_memory
);
978 ret
= objalloc_alloc ((struct objalloc
*) abfd
->memory
, ul_size
);
980 bfd_set_error (bfd_error_no_memory
);
989 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
992 Allocate a block of @var{nmemb} elements of @var{size} bytes each
993 of memory attached to <<abfd>> and return a pointer to it.
997 bfd_alloc2 (bfd
*abfd
, bfd_size_type nmemb
, bfd_size_type size
)
999 if ((nmemb
| size
) >= HALF_BFD_SIZE_TYPE
1001 && nmemb
> ~(bfd_size_type
) 0 / size
)
1003 bfd_set_error (bfd_error_no_memory
);
1007 return bfd_alloc (abfd
, size
* nmemb
);
1015 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
1018 Allocate a block of @var{wanted} bytes of zeroed memory
1019 attached to <<abfd>> and return a pointer to it.
1023 bfd_zalloc (bfd
*abfd
, bfd_size_type size
)
1027 res
= bfd_alloc (abfd
, size
);
1029 memset (res
, 0, (size_t) size
);
1038 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
1041 Allocate a block of @var{nmemb} elements of @var{size} bytes each
1042 of zeroed memory attached to <<abfd>> and return a pointer to it.
1046 bfd_zalloc2 (bfd
*abfd
, bfd_size_type nmemb
, bfd_size_type size
)
1050 if ((nmemb
| size
) >= HALF_BFD_SIZE_TYPE
1052 && nmemb
> ~(bfd_size_type
) 0 / size
)
1054 bfd_set_error (bfd_error_no_memory
);
1060 res
= bfd_alloc (abfd
, size
);
1062 memset (res
, 0, (size_t) size
);
1066 /* Free a block allocated for a BFD.
1067 Note: Also frees all more recently allocated blocks! */
1070 bfd_release (bfd
*abfd
, void *block
)
1072 objalloc_free_block ((struct objalloc
*) abfd
->memory
, block
);
1077 GNU Extension: separate debug-info files
1079 The idea here is that a special section called .gnu_debuglink might be
1080 embedded in a binary file, which indicates that some *other* file
1081 contains the real debugging information. This special section contains a
1082 filename and CRC32 checksum, which we read and resolve to another file,
1085 This facilitates "optional" provision of debugging information, without
1086 having to provide two complete copies of every binary object (with and
1087 without debug symbols). */
1089 #define GNU_DEBUGLINK ".gnu_debuglink"
1090 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1094 bfd_calc_gnu_debuglink_crc32
1097 unsigned long bfd_calc_gnu_debuglink_crc32
1098 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1101 Computes a CRC value as used in the .gnu_debuglink section.
1102 Advances the previously computed @var{crc} value by computing
1103 and adding in the crc32 for @var{len} bytes of @var{buf}.
1106 Return the updated CRC32 value.
1110 bfd_calc_gnu_debuglink_crc32 (unsigned long crc
,
1111 const unsigned char *buf
,
1114 static const unsigned long crc32_table
[256] =
1116 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1117 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1118 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1119 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1120 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1121 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1122 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1123 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1124 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1125 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1126 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1127 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1128 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1129 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1130 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1131 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1132 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1133 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1134 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1135 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1136 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1137 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1138 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1139 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1140 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1141 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1142 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1143 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1144 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1145 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1146 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1147 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1148 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1149 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1150 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1151 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1152 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1153 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1154 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1155 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1156 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1157 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1158 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1159 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1160 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1161 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1162 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1163 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1164 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1165 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1166 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1169 const unsigned char *end
;
1171 crc
= ~crc
& 0xffffffff;
1172 for (end
= buf
+ len
; buf
< end
; ++ buf
)
1173 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
1174 return ~crc
& 0xffffffff;
1180 bfd_get_debug_link_info_1
1183 char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out);
1186 Extracts the filename and CRC32 value for any separate debug
1187 information file associated with @var{abfd}.
1189 The @var{crc32_out} parameter is an untyped pointer because
1190 this routine is used as a @code{get_func_type} function, but it
1191 is expected to be an unsigned long pointer.
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_1 (bfd
*abfd
, void *crc32_out
)
1207 unsigned long *crc32
= (unsigned long *) crc32_out
;
1209 unsigned int crc_offset
;
1212 ufile_ptr file_size
;
1215 BFD_ASSERT (crc32_out
);
1217 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1222 size
= bfd_section_size (sect
);
1223 file_size
= bfd_get_size (abfd
);
1225 /* PR 22794: Make sure that the section has a reasonable size. */
1226 if (size
< 8 || (file_size
!= 0 && size
>= file_size
))
1229 if (!bfd_malloc_and_get_section (abfd
, sect
, &contents
))
1231 if (contents
!= NULL
)
1236 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1237 name
= (char *) contents
;
1238 /* PR 17597: Avoid reading off the end of the buffer. */
1239 crc_offset
= strnlen (name
, size
) + 1;
1240 crc_offset
= (crc_offset
+ 3) & ~3;
1241 if (crc_offset
+ 4 > size
)
1244 *crc32
= bfd_get_32 (abfd
, contents
+ crc_offset
);
1251 bfd_get_debug_link_info
1254 char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1257 Extracts the filename and CRC32 value for any separate debug
1258 information file associated with @var{abfd}.
1261 The filename of the associated debug information file, or NULL
1262 if there is no such file. If the filename was found then the
1263 contents of @var{crc32_out} are updated to hold the corresponding
1264 CRC32 value for the file.
1266 The returned filename is allocated with @code{malloc}; freeing
1267 it is the responsibility of the caller.
1271 bfd_get_debug_link_info (bfd
*abfd
, unsigned long *crc32_out
)
1273 return bfd_get_debug_link_info_1 (abfd
, crc32_out
);
1278 bfd_get_alt_debug_link_info
1281 char *bfd_get_alt_debug_link_info (bfd * abfd,
1282 bfd_size_type *buildid_len,
1283 bfd_byte **buildid_out);
1286 Fetch the filename and BuildID value for any alternate debuginfo
1287 associated with @var{abfd}. Return NULL if no such info found,
1288 otherwise return filename and update @var{buildid_len} and
1289 @var{buildid_out}. The returned filename and build_id are
1290 allocated with @code{malloc}; freeing them is the responsibility
1295 bfd_get_alt_debug_link_info (bfd
* abfd
, bfd_size_type
*buildid_len
,
1296 bfd_byte
**buildid_out
)
1300 unsigned int buildid_offset
;
1303 ufile_ptr file_size
;
1306 BFD_ASSERT (buildid_len
);
1307 BFD_ASSERT (buildid_out
);
1309 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGALTLINK
);
1314 size
= bfd_section_size (sect
);
1315 file_size
= bfd_get_size (abfd
);
1316 if (size
< 8 || (file_size
!= 0 && size
>= file_size
))
1319 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1321 if (contents
!= NULL
)
1326 /* BuildID value is stored after the filename. */
1327 name
= (char *) contents
;
1328 buildid_offset
= strnlen (name
, size
) + 1;
1329 if (buildid_offset
>= bfd_section_size (sect
))
1332 *buildid_len
= size
- buildid_offset
;
1333 *buildid_out
= bfd_malloc (*buildid_len
);
1334 memcpy (*buildid_out
, contents
+ buildid_offset
, *buildid_len
);
1341 separate_debug_file_exists
1344 bfd_boolean separate_debug_file_exists
1345 (char *name, void *crc32_p);
1348 Checks to see if @var{name} is a file and if its contents
1349 match @var{crc32}, which is a pointer to an @code{unsigned
1350 long} containing a CRC32.
1352 The @var{crc32_p} parameter is an untyped pointer because
1353 this routine is used as a @code{check_func_type} function.
1357 separate_debug_file_exists (const char *name
, void *crc32_p
)
1359 static unsigned char buffer
[8 * 1024];
1360 unsigned long file_crc
= 0;
1362 bfd_size_type count
;
1366 BFD_ASSERT (crc32_p
);
1368 crc
= *(unsigned long *) crc32_p
;
1370 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1374 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
1375 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1379 return crc
== file_crc
;
1384 separate_alt_debug_file_exists
1387 bfd_boolean separate_alt_debug_file_exists
1388 (char *name, void *unused);
1391 Checks to see if @var{name} is a file.
1395 separate_alt_debug_file_exists (const char *name
, void *unused ATTRIBUTE_UNUSED
)
1401 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1412 find_separate_debug_file
1415 char *find_separate_debug_file
1416 (bfd *abfd, const char *dir, bfd_boolean include_dirs,
1417 get_func_type get, check_func_type check, void *data);
1420 Searches for a debug information file corresponding to @var{abfd}.
1422 The name of the separate debug info file is returned by the
1423 @var{get} function. This function scans various fixed locations
1424 in the filesystem, including the file tree rooted at @var{dir}.
1425 If the @var{include_dirs} parameter is true then the directory
1426 components of @var{abfd}'s filename will be included in the
1429 @var{data} is passed unmodified to the @var{get} and @var{check}
1430 functions. It is generally used to implement build-id-like
1431 matching in the callback functions.
1434 Returns the filename of the first file to be found which
1435 receives a TRUE result from the @var{check} function.
1436 Returns NULL if no valid file could be found.
1439 typedef char * (* get_func_type
) (bfd
*, void *);
1440 typedef bfd_boolean (* check_func_type
) (const char *, void *);
1443 find_separate_debug_file (bfd
* abfd
,
1444 const char * debug_file_directory
,
1445 bfd_boolean include_dirs
,
1446 get_func_type get_func
,
1447 check_func_type check_func
,
1455 size_t canon_dirlen
;
1458 if (debug_file_directory
== NULL
)
1459 debug_file_directory
= ".";
1461 /* BFD may have been opened from a stream. */
1462 if (abfd
->filename
== NULL
)
1464 bfd_set_error (bfd_error_invalid_operation
);
1468 base
= get_func (abfd
, func_data
);
1473 if (base
[0] == '\0')
1476 bfd_set_error (bfd_error_no_debug_section
);
1482 for (dirlen
= strlen (abfd
->filename
); dirlen
> 0; dirlen
--)
1483 if (IS_DIR_SEPARATOR (abfd
->filename
[dirlen
- 1]))
1486 dir
= (char *) bfd_malloc (dirlen
+ 1);
1492 memcpy (dir
, abfd
->filename
, dirlen
);
1497 dir
= (char *) bfd_malloc (1);
1502 /* Compute the canonical name of the bfd object with all symbolic links
1503 resolved, for use in the global debugfile directory. */
1504 canon_dir
= lrealpath (abfd
->filename
);
1505 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
1506 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
1508 canon_dir
[canon_dirlen
] = '\0';
1510 #ifndef EXTRA_DEBUG_ROOT1
1511 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1513 #ifndef EXTRA_DEBUG_ROOT2
1514 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1517 debugfile
= (char *)
1518 bfd_malloc (strlen (debug_file_directory
) + 1
1519 + (canon_dirlen
> dirlen
? canon_dirlen
: dirlen
)
1520 + strlen (".debug/")
1521 #ifdef EXTRA_DEBUG_ROOT1
1522 + strlen (EXTRA_DEBUG_ROOT1
)
1524 #ifdef EXTRA_DEBUG_ROOT2
1525 + strlen (EXTRA_DEBUG_ROOT2
)
1529 if (debugfile
== NULL
)
1530 goto found
; /* Actually this returns NULL. */
1532 /* First try in the same directory as the original file.
1534 FIXME: Strictly speaking if we are using the build-id method,
1535 (ie include_dirs == FALSE) then we should only check absolute
1536 paths, not relative ones like this one (and the next one).
1537 The check is left in however as this allows the binutils
1538 testsuite to exercise this feature without having to install
1539 a file into the root filesystem. (See binutils/testsuite/
1540 binutils-all/objdump.exp for the test). */
1541 sprintf (debugfile
, "%s%s", dir
, base
);
1542 if (check_func (debugfile
, func_data
))
1545 /* Then try in a subdirectory called .debug. */
1546 sprintf (debugfile
, "%s.debug/%s", dir
, base
);
1547 if (check_func (debugfile
, func_data
))
1550 #ifdef EXTRA_DEBUG_ROOT1
1551 /* Try the first extra debug file root. */
1552 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT1
,
1553 include_dirs
? canon_dir
: "/", base
);
1554 if (check_func (debugfile
, func_data
))
1558 #ifdef EXTRA_DEBUG_ROOT2
1559 /* Try the second extra debug file root. */
1560 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT2
,
1561 include_dirs
? canon_dir
: "/", base
);
1562 if (check_func (debugfile
, func_data
))
1566 /* Then try in the global debugfile directory. */
1567 strcpy (debugfile
, debug_file_directory
);
1568 dirlen
= strlen (debug_file_directory
) - 1;
1572 && debug_file_directory
[dirlen
] != '/'
1573 && canon_dir
[0] != '/')
1574 strcat (debugfile
, "/");
1575 strcat (debugfile
, canon_dir
);
1579 if (dirlen
> 0 && debug_file_directory
[dirlen
] != '/')
1580 strcat (debugfile
, "/");
1582 strcat (debugfile
, base
);
1584 if (check_func (debugfile
, func_data
))
1587 /* Failed to find the file. */
1600 bfd_follow_gnu_debuglink
1603 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1606 Takes a BFD and searches it for a .gnu_debuglink section. If this
1607 section is found, it examines the section for the name and checksum
1608 of a '.debug' file containing auxiliary debugging information. It
1609 then searches the filesystem for this .debug file in some standard
1610 locations, including the directory tree rooted at @var{dir}, and if
1611 found returns the full filename.
1613 If @var{dir} is NULL, the search will take place starting at
1614 the current directory.
1617 <<NULL>> on any errors or failure to locate the .debug file,
1618 otherwise a pointer to a heap-allocated string containing the
1619 filename. The caller is responsible for freeing this string.
1623 bfd_follow_gnu_debuglink (bfd
*abfd
, const char *dir
)
1625 unsigned long crc32
;
1627 return find_separate_debug_file (abfd
, dir
, TRUE
,
1628 bfd_get_debug_link_info_1
,
1629 separate_debug_file_exists
, &crc32
);
1632 /* Helper for bfd_follow_gnu_debugaltlink. It just returns the name
1633 of the separate debug file. */
1636 get_alt_debug_link_info_shim (bfd
* abfd
, void *unused ATTRIBUTE_UNUSED
)
1639 bfd_byte
*buildid
= NULL
;
1640 char *result
= bfd_get_alt_debug_link_info (abfd
, &len
, &buildid
);
1649 bfd_follow_gnu_debugaltlink
1652 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1655 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1656 section is found, it examines the section for the name of a file
1657 containing auxiliary debugging information. It then searches the
1658 filesystem for this file in a set of standard locations, including
1659 the directory tree rooted at @var{dir}, and if found returns the
1662 If @var{dir} is NULL, the search will take place starting at
1663 the current directory.
1666 <<NULL>> on any errors or failure to locate the debug file,
1667 otherwise a pointer to a heap-allocated string containing the
1668 filename. The caller is responsible for freeing this string.
1672 bfd_follow_gnu_debugaltlink (bfd
*abfd
, const char *dir
)
1674 return find_separate_debug_file (abfd
, dir
, TRUE
,
1675 get_alt_debug_link_info_shim
,
1676 separate_alt_debug_file_exists
,
1682 bfd_create_gnu_debuglink_section
1685 struct bfd_section *bfd_create_gnu_debuglink_section
1686 (bfd *abfd, const char *filename);
1689 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The
1690 section is sized to be big enough to contain a link to the specified
1694 A pointer to the new section is returned if all is ok. Otherwise
1695 <<NULL>> is returned and bfd_error is set.
1699 bfd_create_gnu_debuglink_section (bfd
*abfd
, const char *filename
)
1702 bfd_size_type debuglink_size
;
1705 if (abfd
== NULL
|| filename
== NULL
)
1707 bfd_set_error (bfd_error_invalid_operation
);
1711 /* Strip off any path components in filename. */
1712 filename
= lbasename (filename
);
1714 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1717 /* Section already exists. */
1718 bfd_set_error (bfd_error_invalid_operation
);
1722 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DEBUGGING
;
1723 sect
= bfd_make_section_with_flags (abfd
, GNU_DEBUGLINK
, flags
);
1727 /* Compute the size of the section. Allow for the CRC after the filename,
1728 and padding so that it will start on a 4-byte boundary. */
1729 debuglink_size
= strlen (filename
) + 1;
1730 debuglink_size
+= 3;
1731 debuglink_size
&= ~3;
1732 debuglink_size
+= 4;
1734 if (!bfd_set_section_size (sect
, debuglink_size
))
1735 /* XXX Should we delete the section from the bfd ? */
1738 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1739 Note - despite the name of the function being called, we are
1740 setting an alignment power, not a byte alignment value. */
1741 bfd_set_section_alignment (sect
, 2);
1749 bfd_fill_in_gnu_debuglink_section
1752 bfd_boolean bfd_fill_in_gnu_debuglink_section
1753 (bfd *abfd, struct bfd_section *sect, const char *filename);
1756 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1757 and fills in the contents of the section to contain a link to the
1758 specified @var{filename}. The filename should be relative to the
1762 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1763 and bfd_error is set.
1767 bfd_fill_in_gnu_debuglink_section (bfd
*abfd
,
1768 struct bfd_section
*sect
,
1769 const char *filename
)
1771 bfd_size_type debuglink_size
;
1772 unsigned long crc32
;
1774 bfd_size_type crc_offset
;
1776 static unsigned char buffer
[8 * 1024];
1780 if (abfd
== NULL
|| sect
== NULL
|| filename
== NULL
)
1782 bfd_set_error (bfd_error_invalid_operation
);
1786 /* Make sure that we can read the file.
1787 XXX - Should we attempt to locate the debug info file using the same
1788 algorithm as gdb ? At the moment, since we are creating the
1789 .gnu_debuglink section, we insist upon the user providing us with a
1790 correct-for-section-creation-time path, but this need not conform to
1791 the gdb location algorithm. */
1792 handle
= _bfd_real_fopen (filename
, FOPEN_RB
);
1795 bfd_set_error (bfd_error_system_call
);
1800 while ((count
= fread (buffer
, 1, sizeof buffer
, handle
)) > 0)
1801 crc32
= bfd_calc_gnu_debuglink_crc32 (crc32
, buffer
, count
);
1804 /* Strip off any path components in filename,
1805 now that we no longer need them. */
1806 filename
= lbasename (filename
);
1808 filelen
= strlen (filename
);
1809 debuglink_size
= filelen
+ 1;
1810 debuglink_size
+= 3;
1811 debuglink_size
&= ~3;
1812 debuglink_size
+= 4;
1814 contents
= (char *) bfd_malloc (debuglink_size
);
1815 if (contents
== NULL
)
1817 /* XXX Should we delete the section from the bfd ? */
1821 crc_offset
= debuglink_size
- 4;
1822 memcpy (contents
, filename
, filelen
);
1823 memset (contents
+ filelen
, 0, crc_offset
- filelen
);
1825 bfd_put_32 (abfd
, crc32
, contents
+ crc_offset
);
1827 if (! bfd_set_section_contents (abfd
, sect
, contents
, 0, debuglink_size
))
1829 /* XXX Should we delete the section from the bfd ? */
1842 struct bfd_build_id * get_build_id (bfd *abfd);
1845 Finds the build-id associated with @var{abfd}. If the build-id is
1846 extracted from the note section then a build-id structure is built
1847 for it, using memory allocated to @var{abfd}, and this is then
1848 attached to the @var{abfd}.
1851 Returns a pointer to the build-id structure if a build-id could be
1852 found. If no build-id is found NULL is returned and error code is
1856 static struct bfd_build_id
*
1857 get_build_id (bfd
*abfd
)
1859 struct bfd_build_id
*build_id
;
1860 Elf_Internal_Note inote
;
1861 Elf_External_Note
*enote
;
1868 if (abfd
->build_id
&& abfd
->build_id
->size
> 0)
1869 /* Save some time by using the already computed build-id. */
1870 return (struct bfd_build_id
*) abfd
->build_id
;
1872 sect
= bfd_get_section_by_name (abfd
, ".note.gnu.build-id");
1875 bfd_set_error (bfd_error_no_debug_section
);
1879 size
= bfd_section_size (sect
);
1880 /* FIXME: Should we support smaller build-id notes ? */
1883 bfd_set_error (bfd_error_invalid_operation
);
1887 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1889 if (contents
!= NULL
)
1894 /* FIXME: Paranoia - allow for compressed build-id sections.
1895 Maybe we should complain if this size is different from
1896 the one obtained above... */
1897 size
= bfd_section_size (sect
);
1898 if (size
< sizeof (Elf_External_Note
))
1900 bfd_set_error (bfd_error_invalid_operation
);
1905 enote
= (Elf_External_Note
*) contents
;
1906 inote
.type
= H_GET_32 (abfd
, enote
->type
);
1907 inote
.namesz
= H_GET_32 (abfd
, enote
->namesz
);
1908 inote
.namedata
= enote
->name
;
1909 inote
.descsz
= H_GET_32 (abfd
, enote
->descsz
);
1910 inote
.descdata
= inote
.namedata
+ BFD_ALIGN (inote
.namesz
, 4);
1911 /* FIXME: Should we check for extra notes in this section ? */
1913 if (inote
.descsz
<= 0
1914 || inote
.type
!= NT_GNU_BUILD_ID
1915 || inote
.namesz
!= 4 /* sizeof "GNU" */
1916 || strncmp (inote
.namedata
, "GNU", 4) != 0
1917 || inote
.descsz
> 0x7ffffffe
1918 || size
< (12 + BFD_ALIGN (inote
.namesz
, 4) + inote
.descsz
))
1921 bfd_set_error (bfd_error_invalid_operation
);
1925 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) + inote
.descsz
);
1926 if (build_id
== NULL
)
1932 build_id
->size
= inote
.descsz
;
1933 memcpy (build_id
->data
, inote
.descdata
, inote
.descsz
);
1934 abfd
->build_id
= build_id
;
1945 char * get_build_id_name (bfd *abfd, void *build_id_out_p)
1948 Searches @var{abfd} for a build-id, and then constructs a pathname
1949 from it. The path is computed as .build-id/NN/NN+NN.debug where
1950 NNNN+NN is the build-id value as a hexadecimal string.
1953 Returns the constructed filename or NULL upon error.
1954 It is the caller's responsibility to free the memory used to hold the
1956 If a filename is returned then the @var{build_id_out_p}
1957 parameter (which points to a @code{struct bfd_build_id}
1958 pointer) is set to a pointer to the build_id structure.
1962 get_build_id_name (bfd
*abfd
, void *build_id_out_p
)
1964 struct bfd_build_id
**build_id_out
= build_id_out_p
;
1965 struct bfd_build_id
*build_id
;
1971 if (abfd
== NULL
|| abfd
->filename
== NULL
|| build_id_out
== NULL
)
1973 bfd_set_error (bfd_error_invalid_operation
);
1977 build_id
= get_build_id (abfd
);
1978 if (build_id
== NULL
)
1981 /* Compute the debug pathname corresponding to the build-id. */
1982 name
= bfd_malloc (strlen (".build-id/") + build_id
->size
* 2 + 2 + strlen (".debug"));
1985 bfd_set_error (bfd_error_no_memory
);
1992 n
+= sprintf (n
, ".build-id/");
1993 n
+= sprintf (n
, "%02x", (unsigned) *d
++); s
--;
1994 n
+= sprintf (n
, "/");
1996 n
+= sprintf (n
, "%02x", (unsigned) *d
++);
1997 n
+= sprintf (n
, ".debug");
1999 *build_id_out
= build_id
;
2008 bfd_boolean check_build_id_file (char *name, void *buildid_p);
2011 Checks to see if @var{name} is a readable file and if its build-id
2012 matches @var{buildid}.
2015 Returns TRUE if the file exists, is readable, and contains a
2016 build-id which matches the build-id pointed at by
2017 @var{build_id_p} (which is really a @code{struct bfd_build_id **}).
2021 check_build_id_file (const char *name
, void *buildid_p
)
2023 struct bfd_build_id
*orig_build_id
;
2024 struct bfd_build_id
*build_id
;
2029 BFD_ASSERT (buildid_p
);
2031 file
= bfd_openr (name
, NULL
);
2035 /* If the file is an archive, process all of its elements. */
2036 if (! bfd_check_format (file
, bfd_object
))
2042 build_id
= get_build_id (file
);
2043 if (build_id
== NULL
)
2049 orig_build_id
= *(struct bfd_build_id
**) buildid_p
;
2051 result
= build_id
->size
== orig_build_id
->size
2052 && memcmp (build_id
->data
, orig_build_id
->data
, build_id
->size
) == 0;
2054 (void) bfd_close (file
);
2061 bfd_follow_build_id_debuglink
2064 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
2067 Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2068 If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2069 note, which should be a hexadecimal value @var{NNNN+NN} (for
2070 32+ hex digits). It then searches the filesystem for a file named
2071 @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2072 including the directory tree rooted at @var{dir}. The filename
2073 of the first matching file to be found is returned. A matching
2074 file should contain a .note.gnu.build-id section with the same
2075 @var{NNNN+NN} note as @var{abfd}, although this check is currently
2078 If @var{dir} is NULL, the search will take place starting at
2079 the current directory.
2082 <<NULL>> on any errors or failure to locate the debug file,
2083 otherwise a pointer to a heap-allocated string containing the
2084 filename. The caller is responsible for freeing this string.
2088 bfd_follow_build_id_debuglink (bfd
*abfd
, const char *dir
)
2090 struct bfd_build_id
*build_id
;
2092 return find_separate_debug_file (abfd
, dir
, FALSE
,
2094 check_build_id_file
, &build_id
);
2102 void bfd_set_filename (bfd *abfd, char *filename);
2105 Set the filename of @var{abfd}. The old filename, if any, is freed.
2106 @var{filename} must be allocated using @code{xmalloc}. After
2107 this call, it is owned @var{abfd}.
2111 bfd_set_filename (bfd
*abfd
, char *filename
)
2113 free ((char *) abfd
->filename
);
2114 abfd
->filename
= filename
;