1 /* opncls.c -- open and close a BFD.
2 Copyright (C) 1990-2017 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
);
226 _bfd_delete_bfd (nbfd
);
230 /* OK, put everything where it belongs. */
232 /* PR 11983: Do not cache the original filename, but
233 rather make a copy - the original might go away. */
234 nbfd
->filename
= xstrdup (filename
);
236 /* Figure out whether the user is opening the file for reading,
237 writing, or both, by looking at the MODE argument. */
238 if ((mode
[0] == 'r' || mode
[0] == 'w' || mode
[0] == 'a')
240 nbfd
->direction
= both_direction
;
241 else if (mode
[0] == 'r')
242 nbfd
->direction
= read_direction
;
244 nbfd
->direction
= write_direction
;
246 if (! bfd_cache_init (nbfd
))
248 _bfd_delete_bfd (nbfd
);
251 nbfd
->opened_once
= TRUE
;
253 /* If we opened the file by name, mark it cacheable; we can close it
254 and reopen it later. However, if a file descriptor was provided,
255 then it may have been opened with special flags that make it
256 unsafe to close and reopen the file. */
258 (void) bfd_set_cacheable (nbfd
, TRUE
);
268 bfd *bfd_openr (const char *filename, const char *target);
271 Open the file @var{filename} (using <<fopen>>) with the target
272 @var{target}. Return a pointer to the created BFD.
274 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
277 If <<NULL>> is returned then an error has occured. Possible errors
278 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
279 <<system_call>> error.
281 A copy of the @var{filename} argument is stored in the newly created
282 BFD. It can be accessed via the bfd_get_filename() macro.
286 bfd_openr (const char *filename
, const char *target
)
288 return bfd_fopen (filename
, target
, FOPEN_RB
, -1);
291 /* Don't try to `optimize' this function:
293 o - We lock using stack space so that interrupting the locking
294 won't cause a storage leak.
295 o - We open the file stream last, since we don't want to have to
296 close it if anything goes wrong. Closing the stream means closing
297 the file descriptor too, even though we didn't open it. */
303 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
306 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
307 <<fopen>>. It opens a BFD on a file already described by the
310 When the file is later <<bfd_close>>d, the file descriptor will
311 be closed. If the caller desires that this file descriptor be
312 cached by BFD (opened as needed, closed as needed to free
313 descriptors for other opens), with the supplied @var{fd} used as
314 an initial file descriptor (but subject to closure at any time),
315 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
316 is to assume no caching; the file descriptor will remain open
317 until <<bfd_close>>, and will not be affected by BFD operations
320 Possible errors are <<bfd_error_no_memory>>,
321 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
323 On error, @var{fd} is closed.
325 A copy of the @var{filename} argument is stored in the newly created
326 BFD. It can be accessed via the bfd_get_filename() macro.
330 bfd_fdopenr (const char *filename
, const char *target
, int fd
)
333 #if defined(HAVE_FCNTL) && defined(F_GETFL)
337 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
338 mode
= FOPEN_RUB
; /* Assume full access. */
340 fdflags
= fcntl (fd
, F_GETFL
, NULL
);
347 bfd_set_error (bfd_error_system_call
);
351 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
352 switch (fdflags
& (O_ACCMODE
))
354 case O_RDONLY
: mode
= FOPEN_RB
; break;
355 case O_WRONLY
: mode
= FOPEN_RUB
; break;
356 case O_RDWR
: mode
= FOPEN_RUB
; break;
361 return bfd_fopen (filename
, target
, mode
, fd
);
369 bfd *bfd_openstreamr (const char * filename, const char * target,
373 Open a BFD for read access on an existing stdio stream. When
374 the BFD is passed to <<bfd_close>>, the stream will be closed.
376 A copy of the @var{filename} argument is stored in the newly created
377 BFD. It can be accessed via the bfd_get_filename() macro.
381 bfd_openstreamr (const char *filename
, const char *target
, void *streamarg
)
383 FILE *stream
= (FILE *) streamarg
;
385 const bfd_target
*target_vec
;
387 nbfd
= _bfd_new_bfd ();
391 target_vec
= bfd_find_target (target
, nbfd
);
392 if (target_vec
== NULL
)
394 _bfd_delete_bfd (nbfd
);
398 nbfd
->iostream
= stream
;
399 /* PR 11983: Do not cache the original filename, but
400 rather make a copy - the original might go away. */
401 nbfd
->filename
= xstrdup (filename
);
402 nbfd
->direction
= read_direction
;
404 if (! bfd_cache_init (nbfd
))
406 _bfd_delete_bfd (nbfd
);
418 bfd *bfd_openr_iovec (const char *filename, const char *target,
419 void *(*open_func) (struct bfd *nbfd,
422 file_ptr (*pread_func) (struct bfd *nbfd,
427 int (*close_func) (struct bfd *nbfd,
429 int (*stat_func) (struct bfd *abfd,
434 Create and return a BFD backed by a read-only @var{stream}.
435 The @var{stream} is created using @var{open_func}, accessed using
436 @var{pread_func} and destroyed using @var{close_func}.
438 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
441 Calls @var{open_func} (which can call <<bfd_zalloc>> and
442 <<bfd_get_filename>>) to obtain the read-only stream backing
443 the BFD. @var{open_func} either succeeds returning the
444 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
445 (setting <<bfd_error>>).
447 Calls @var{pread_func} to request @var{nbytes} of data from
448 @var{stream} starting at @var{offset} (e.g., via a call to
449 <<bfd_read>>). @var{pread_func} either succeeds returning the
450 number of bytes read (which can be less than @var{nbytes} when
451 end-of-file), or fails returning -1 (setting <<bfd_error>>).
453 Calls @var{close_func} when the BFD is later closed using
454 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
455 fails returning -1 (setting <<bfd_error>>).
457 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
458 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
459 on success, or returns -1 on failure (setting <<bfd_error>>).
461 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
462 occurred. Possible errors are <<bfd_error_no_memory>>,
463 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
465 A copy of the @var{filename} argument is stored in the newly created
466 BFD. It can be accessed via the bfd_get_filename() macro.
472 file_ptr (*pread
) (struct bfd
*abfd
, void *stream
, void *buf
,
473 file_ptr nbytes
, file_ptr offset
);
474 int (*close
) (struct bfd
*abfd
, void *stream
);
475 int (*stat
) (struct bfd
*abfd
, void *stream
, struct stat
*sb
);
480 opncls_btell (struct bfd
*abfd
)
482 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
487 opncls_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
489 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
492 case SEEK_SET
: vec
->where
= offset
; break;
493 case SEEK_CUR
: vec
->where
+= offset
; break;
494 case SEEK_END
: return -1;
500 opncls_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
502 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
503 file_ptr nread
= (vec
->pread
) (abfd
, vec
->stream
, buf
, nbytes
, vec
->where
);
512 opncls_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
513 const void *where ATTRIBUTE_UNUSED
,
514 file_ptr nbytes ATTRIBUTE_UNUSED
)
520 opncls_bclose (struct bfd
*abfd
)
522 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
523 /* Since the VEC's memory is bound to the bfd deleting the bfd will
527 if (vec
->close
!= NULL
)
528 status
= (vec
->close
) (abfd
, vec
->stream
);
529 abfd
->iostream
= NULL
;
534 opncls_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
540 opncls_bstat (struct bfd
*abfd
, struct stat
*sb
)
542 struct opncls
*vec
= (struct opncls
*) abfd
->iostream
;
544 memset (sb
, 0, sizeof (*sb
));
545 if (vec
->stat
== NULL
)
548 return (vec
->stat
) (abfd
, vec
->stream
, sb
);
552 opncls_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
553 void *addr ATTRIBUTE_UNUSED
,
554 bfd_size_type len ATTRIBUTE_UNUSED
,
555 int prot ATTRIBUTE_UNUSED
,
556 int flags ATTRIBUTE_UNUSED
,
557 file_ptr offset ATTRIBUTE_UNUSED
,
558 void **map_addr ATTRIBUTE_UNUSED
,
559 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
564 static const struct bfd_iovec opncls_iovec
=
566 &opncls_bread
, &opncls_bwrite
, &opncls_btell
, &opncls_bseek
,
567 &opncls_bclose
, &opncls_bflush
, &opncls_bstat
, &opncls_bmmap
571 bfd_openr_iovec (const char *filename
, const char *target
,
572 void *(*open_p
) (struct bfd
*, void *),
574 file_ptr (*pread_p
) (struct bfd
*, void *, void *,
576 int (*close_p
) (struct bfd
*, void *),
577 int (*stat_p
) (struct bfd
*, void *, struct stat
*))
580 const bfd_target
*target_vec
;
584 nbfd
= _bfd_new_bfd ();
588 target_vec
= bfd_find_target (target
, nbfd
);
589 if (target_vec
== NULL
)
591 _bfd_delete_bfd (nbfd
);
595 /* PR 11983: Do not cache the original filename, but
596 rather make a copy - the original might go away. */
597 nbfd
->filename
= xstrdup (filename
);
598 nbfd
->direction
= read_direction
;
600 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
601 stream
= (*open_p
) (nbfd
, open_closure
);
604 _bfd_delete_bfd (nbfd
);
608 vec
= (struct opncls
*) bfd_zalloc (nbfd
, sizeof (struct opncls
));
609 vec
->stream
= stream
;
610 vec
->pread
= pread_p
;
611 vec
->close
= close_p
;
614 nbfd
->iovec
= &opncls_iovec
;
615 nbfd
->iostream
= vec
;
620 /* bfd_openw -- open for writing.
621 Returns a pointer to a freshly-allocated BFD on success, or NULL.
623 See comment by bfd_fdopenr before you try to modify this function. */
630 bfd *bfd_openw (const char *filename, const char *target);
633 Create a BFD, associated with file @var{filename}, using the
634 file format @var{target}, and return a pointer to it.
636 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
637 <<bfd_error_invalid_target>>.
639 A copy of the @var{filename} argument is stored in the newly created
640 BFD. It can be accessed via the bfd_get_filename() macro.
644 bfd_openw (const char *filename
, const char *target
)
647 const bfd_target
*target_vec
;
649 /* nbfd has to point to head of malloc'ed block so that bfd_close may
650 reclaim it correctly. */
651 nbfd
= _bfd_new_bfd ();
655 target_vec
= bfd_find_target (target
, nbfd
);
656 if (target_vec
== NULL
)
658 _bfd_delete_bfd (nbfd
);
662 /* PR 11983: Do not cache the original filename, but
663 rather make a copy - the original might go away. */
664 nbfd
->filename
= xstrdup (filename
);
665 nbfd
->direction
= write_direction
;
667 if (bfd_open_file (nbfd
) == NULL
)
669 /* File not writeable, etc. */
670 bfd_set_error (bfd_error_system_call
);
671 _bfd_delete_bfd (nbfd
);
679 _maybe_make_executable (bfd
* abfd
)
681 /* If the file was open for writing and is now executable,
683 if (abfd
->direction
== write_direction
684 && (abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
688 if (stat (abfd
->filename
, &buf
) == 0
689 /* Do not attempt to change non-regular files. This is
690 here especially for configure scripts and kernel builds
691 which run tests with "ld [...] -o /dev/null". */
692 && S_ISREG(buf
.st_mode
))
694 unsigned int mask
= umask (0);
697 chmod (abfd
->filename
,
699 & (buf
.st_mode
| ((S_IXUSR
| S_IXGRP
| S_IXOTH
) &~ mask
))));
709 bfd_boolean bfd_close (bfd *abfd);
712 Close a BFD. If the BFD was open for writing, then pending
713 operations are completed and the file written out and closed.
714 If the created file is executable, then <<chmod>> is called
717 All memory attached to the BFD is released.
719 The file descriptor associated with the BFD is closed (even
720 if it was passed in to BFD by <<bfd_fdopenr>>).
723 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
727 bfd_close (bfd
*abfd
)
731 if (bfd_write_p (abfd
))
733 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
737 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
740 ret
= abfd
->iovec
->bclose (abfd
) == 0;
743 _maybe_make_executable (abfd
);
745 _bfd_delete_bfd (abfd
);
755 bfd_boolean bfd_close_all_done (bfd *);
758 Close a BFD. Differs from <<bfd_close>> since it does not
759 complete any pending operations. This routine would be used
760 if the application had just used BFD for swapping and didn't
761 want to use any of the writing code.
763 If the created file is executable, then <<chmod>> is called
766 All memory attached to the BFD is released.
769 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
773 bfd_close_all_done (bfd
*abfd
)
777 ret
= bfd_cache_close (abfd
);
780 _maybe_make_executable (abfd
);
782 _bfd_delete_bfd (abfd
);
792 bfd *bfd_create (const char *filename, bfd *templ);
795 Create a new BFD in the manner of <<bfd_openw>>, but without
796 opening a file. The new BFD takes the target from the target
797 used by @var{templ}. The format is always set to <<bfd_object>>.
799 A copy of the @var{filename} argument is stored in the newly created
800 BFD. It can be accessed via the bfd_get_filename() macro.
804 bfd_create (const char *filename
, bfd
*templ
)
808 nbfd
= _bfd_new_bfd ();
811 /* PR 11983: Do not cache the original filename, but
812 rather make a copy - the original might go away. */
813 nbfd
->filename
= xstrdup (filename
);
815 nbfd
->xvec
= templ
->xvec
;
816 nbfd
->direction
= no_direction
;
817 bfd_set_format (nbfd
, bfd_object
);
827 bfd_boolean bfd_make_writable (bfd *abfd);
830 Takes a BFD as created by <<bfd_create>> and converts it
831 into one like as returned by <<bfd_openw>>. It does this
832 by converting the BFD to BFD_IN_MEMORY. It's assumed that
833 you will call <<bfd_make_readable>> on this bfd later.
836 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
840 bfd_make_writable (bfd
*abfd
)
842 struct bfd_in_memory
*bim
;
844 if (abfd
->direction
!= no_direction
)
846 bfd_set_error (bfd_error_invalid_operation
);
850 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
852 return FALSE
; /* bfd_error already set. */
853 abfd
->iostream
= bim
;
854 /* bfd_bwrite will grow these as needed. */
858 abfd
->flags
|= BFD_IN_MEMORY
;
859 abfd
->iovec
= &_bfd_memory_iovec
;
861 abfd
->direction
= write_direction
;
872 bfd_boolean bfd_make_readable (bfd *abfd);
875 Takes a BFD as created by <<bfd_create>> and
876 <<bfd_make_writable>> and converts it into one like as
877 returned by <<bfd_openr>>. It does this by writing the
878 contents out to the memory buffer, then reversing the
882 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
885 bfd_make_readable (bfd
*abfd
)
887 if (abfd
->direction
!= write_direction
|| !(abfd
->flags
& BFD_IN_MEMORY
))
889 bfd_set_error (bfd_error_invalid_operation
);
893 if (! BFD_SEND_FMT (abfd
, _bfd_write_contents
, (abfd
)))
896 if (! BFD_SEND (abfd
, _close_and_cleanup
, (abfd
)))
899 abfd
->arch_info
= &bfd_default_arch_struct
;
902 abfd
->format
= bfd_unknown
;
903 abfd
->my_archive
= NULL
;
905 abfd
->opened_once
= FALSE
;
906 abfd
->output_has_begun
= FALSE
;
907 abfd
->section_count
= 0;
908 abfd
->usrdata
= NULL
;
909 abfd
->cacheable
= FALSE
;
910 abfd
->flags
|= BFD_IN_MEMORY
;
911 abfd
->mtime_set
= FALSE
;
913 abfd
->target_defaulted
= TRUE
;
914 abfd
->direction
= read_direction
;
917 abfd
->outsymbols
= 0;
920 bfd_section_list_clear (abfd
);
921 bfd_check_format (abfd
, bfd_object
);
931 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
934 Allocate a block of @var{wanted} bytes of memory attached to
935 <<abfd>> and return a pointer to it.
939 bfd_alloc (bfd
*abfd
, bfd_size_type size
)
942 unsigned long ul_size
= (unsigned long) size
;
945 /* Note - although objalloc_alloc takes an unsigned long as its
946 argument, internally the size is treated as a signed long. This can
947 lead to problems where, for example, a request to allocate -1 bytes
948 can result in just 1 byte being allocated, rather than
949 ((unsigned long) -1) bytes. Also memory checkers will often
950 complain about attempts to allocate a negative amount of memory.
951 So to stop these problems we fail if the size is negative. */
952 || ((signed long) ul_size
) < 0)
954 bfd_set_error (bfd_error_no_memory
);
958 ret
= objalloc_alloc ((struct objalloc
*) abfd
->memory
, ul_size
);
960 bfd_set_error (bfd_error_no_memory
);
969 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
972 Allocate a block of @var{nmemb} elements of @var{size} bytes each
973 of memory attached to <<abfd>> and return a pointer to it.
977 bfd_alloc2 (bfd
*abfd
, bfd_size_type nmemb
, bfd_size_type size
)
979 if ((nmemb
| size
) >= HALF_BFD_SIZE_TYPE
981 && nmemb
> ~(bfd_size_type
) 0 / size
)
983 bfd_set_error (bfd_error_no_memory
);
987 return bfd_alloc (abfd
, size
* nmemb
);
995 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
998 Allocate a block of @var{wanted} bytes of zeroed memory
999 attached to <<abfd>> and return a pointer to it.
1003 bfd_zalloc (bfd
*abfd
, bfd_size_type size
)
1007 res
= bfd_alloc (abfd
, size
);
1009 memset (res
, 0, (size_t) size
);
1018 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
1021 Allocate a block of @var{nmemb} elements of @var{size} bytes each
1022 of zeroed memory attached to <<abfd>> and return a pointer to it.
1026 bfd_zalloc2 (bfd
*abfd
, bfd_size_type nmemb
, bfd_size_type size
)
1030 if ((nmemb
| size
) >= HALF_BFD_SIZE_TYPE
1032 && nmemb
> ~(bfd_size_type
) 0 / size
)
1034 bfd_set_error (bfd_error_no_memory
);
1040 res
= bfd_alloc (abfd
, size
);
1042 memset (res
, 0, (size_t) size
);
1046 /* Free a block allocated for a BFD.
1047 Note: Also frees all more recently allocated blocks! */
1050 bfd_release (bfd
*abfd
, void *block
)
1052 objalloc_free_block ((struct objalloc
*) abfd
->memory
, block
);
1057 GNU Extension: separate debug-info files
1059 The idea here is that a special section called .gnu_debuglink might be
1060 embedded in a binary file, which indicates that some *other* file
1061 contains the real debugging information. This special section contains a
1062 filename and CRC32 checksum, which we read and resolve to another file,
1065 This facilitates "optional" provision of debugging information, without
1066 having to provide two complete copies of every binary object (with and
1067 without debug symbols). */
1069 #define GNU_DEBUGLINK ".gnu_debuglink"
1070 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1074 bfd_calc_gnu_debuglink_crc32
1077 unsigned long bfd_calc_gnu_debuglink_crc32
1078 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1081 Computes a CRC value as used in the .gnu_debuglink section.
1082 Advances the previously computed @var{crc} value by computing
1083 and adding in the crc32 for @var{len} bytes of @var{buf}.
1086 Return the updated CRC32 value.
1090 bfd_calc_gnu_debuglink_crc32 (unsigned long crc
,
1091 const unsigned char *buf
,
1094 static const unsigned long crc32_table
[256] =
1096 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1097 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1098 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1099 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1100 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1101 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1102 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1103 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1104 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1105 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1106 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1107 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1108 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1109 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1110 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1111 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1112 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1113 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1114 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1115 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1116 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1117 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1118 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1119 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1120 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1121 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1122 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1123 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1124 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1125 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1126 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1127 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1128 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1129 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1130 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1131 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1132 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1133 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1134 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1135 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1136 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1137 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1138 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1139 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1140 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1141 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1142 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1143 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1144 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1145 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1146 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1149 const unsigned char *end
;
1151 crc
= ~crc
& 0xffffffff;
1152 for (end
= buf
+ len
; buf
< end
; ++ buf
)
1153 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
1154 return ~crc
& 0xffffffff;
1160 bfd_get_debug_link_info_1
1163 char *bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out);
1166 Extracts the filename and CRC32 value for any separate debug
1167 information file associated with @var{abfd}.
1169 The @var{crc32_out} parameter is an untyped pointer because
1170 this routine is used as a @code{get_func_type} function, but it
1171 is expected to be an unsigned long pointer.
1174 The filename of the associated debug information file, or NULL
1175 if there is no such file. If the filename was found then the
1176 contents of @var{crc32_out} are updated to hold the corresponding
1177 CRC32 value for the file.
1179 The returned filename is allocated with @code{malloc}; freeing
1180 it is the responsibility of the caller.
1184 bfd_get_debug_link_info_1 (bfd
*abfd
, void *crc32_out
)
1187 unsigned long *crc32
= (unsigned long *) crc32_out
;
1189 unsigned int crc_offset
;
1193 BFD_ASSERT (crc32_out
);
1195 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1200 if (!bfd_malloc_and_get_section (abfd
, sect
, &contents
))
1202 if (contents
!= NULL
)
1207 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1208 name
= (char *) contents
;
1209 /* PR 17597: avoid reading off the end of the buffer. */
1210 crc_offset
= strnlen (name
, bfd_get_section_size (sect
)) + 1;
1211 crc_offset
= (crc_offset
+ 3) & ~3;
1212 if (crc_offset
>= bfd_get_section_size (sect
))
1215 *crc32
= bfd_get_32 (abfd
, contents
+ crc_offset
);
1222 bfd_get_debug_link_info
1225 char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1228 Extracts the filename and CRC32 value for any separate debug
1229 information file associated with @var{abfd}.
1232 The filename of the associated debug information file, or NULL
1233 if there is no such file. If the filename was found then the
1234 contents of @var{crc32_out} are updated to hold the corresponding
1235 CRC32 value for the file.
1237 The returned filename is allocated with @code{malloc}; freeing
1238 it is the responsibility of the caller.
1242 bfd_get_debug_link_info (bfd
*abfd
, unsigned long *crc32_out
)
1244 return bfd_get_debug_link_info_1 (abfd
, crc32_out
);
1249 bfd_get_alt_debug_link_info
1252 char *bfd_get_alt_debug_link_info (bfd * abfd,
1253 bfd_size_type *buildid_len,
1254 bfd_byte **buildid_out);
1257 Fetch the filename and BuildID value for any alternate debuginfo
1258 associated with @var{abfd}. Return NULL if no such info found,
1259 otherwise return filename and update @var{buildid_len} and
1260 @var{buildid_out}. The returned filename and build_id are
1261 allocated with @code{malloc}; freeing them is the responsibility
1266 bfd_get_alt_debug_link_info (bfd
* abfd
, bfd_size_type
*buildid_len
,
1267 bfd_byte
**buildid_out
)
1271 unsigned int buildid_offset
;
1275 BFD_ASSERT (buildid_len
);
1276 BFD_ASSERT (buildid_out
);
1278 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGALTLINK
);
1283 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1285 if (contents
!= NULL
)
1290 /* BuildID value is stored after the filename. */
1291 name
= (char *) contents
;
1292 buildid_offset
= strnlen (name
, bfd_get_section_size (sect
)) + 1;
1293 if (buildid_offset
>= bfd_get_section_size (sect
))
1296 *buildid_len
= bfd_get_section_size (sect
) - buildid_offset
;
1297 *buildid_out
= bfd_malloc (*buildid_len
);
1298 memcpy (*buildid_out
, contents
+ buildid_offset
, *buildid_len
);
1305 separate_debug_file_exists
1308 bfd_boolean separate_debug_file_exists
1309 (char *name, void *crc32_p);
1312 Checks to see if @var{name} is a file and if its contents
1313 match @var{crc32}, which is a pointer to an @code{unsigned
1314 long} containing a CRC32.
1316 The @var{crc32_p} parameter is an untyped pointer because
1317 this routine is used as a @code{check_func_type} function.
1321 separate_debug_file_exists (const char *name
, void *crc32_p
)
1323 static unsigned char buffer
[8 * 1024];
1324 unsigned long file_crc
= 0;
1326 bfd_size_type count
;
1330 BFD_ASSERT (crc32_p
);
1332 crc
= *(unsigned long *) crc32_p
;
1334 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1338 while ((count
= fread (buffer
, 1, sizeof (buffer
), f
)) > 0)
1339 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
1343 return crc
== file_crc
;
1348 separate_alt_debug_file_exists
1351 bfd_boolean separate_alt_debug_file_exists
1352 (char *name, void *unused);
1355 Checks to see if @var{name} is a file.
1359 separate_alt_debug_file_exists (const char *name
, void *unused ATTRIBUTE_UNUSED
)
1365 f
= _bfd_real_fopen (name
, FOPEN_RB
);
1376 find_separate_debug_file
1379 char *find_separate_debug_file
1380 (bfd *abfd, const char *dir, bfd_boolean include_dirs,
1381 get_func_type get, check_func_type check, void *data);
1384 Searches for a debug information file corresponding to @var{abfd}.
1386 The name of the separate debug info file is returned by the
1387 @var{get} function. This function scans various fixed locations
1388 in the filesystem, including the file tree rooted at @var{dir}.
1389 If the @var{include_dirs} parameter is true then the directory
1390 components of @var{abfd}'s filename will be included in the
1393 @var{data} is passed unmodified to the @var{get} and @var{check}
1394 functions. It is generally used to implement build-id-like
1395 matching in the callback functions.
1398 Returns the filename of the first file to be found which
1399 receives a TRUE result from the @var{check} function.
1400 Returns NULL if no valid file could be found.
1403 typedef char * (* get_func_type
) (bfd
*, void *);
1404 typedef bfd_boolean (* check_func_type
) (const char *, void *);
1407 find_separate_debug_file (bfd
* abfd
,
1408 const char * debug_file_directory
,
1409 bfd_boolean include_dirs
,
1410 get_func_type get_func
,
1411 check_func_type check_func
,
1419 size_t canon_dirlen
;
1422 if (debug_file_directory
== NULL
)
1423 debug_file_directory
= ".";
1425 /* BFD may have been opened from a stream. */
1426 if (abfd
->filename
== NULL
)
1428 bfd_set_error (bfd_error_invalid_operation
);
1432 base
= get_func (abfd
, func_data
);
1437 if (base
[0] == '\0')
1440 bfd_set_error (bfd_error_no_debug_section
);
1446 for (dirlen
= strlen (abfd
->filename
); dirlen
> 0; dirlen
--)
1447 if (IS_DIR_SEPARATOR (abfd
->filename
[dirlen
- 1]))
1450 dir
= (char *) bfd_malloc (dirlen
+ 1);
1456 memcpy (dir
, abfd
->filename
, dirlen
);
1461 dir
= (char *) bfd_malloc (1);
1466 /* Compute the canonical name of the bfd object with all symbolic links
1467 resolved, for use in the global debugfile directory. */
1468 canon_dir
= lrealpath (abfd
->filename
);
1469 for (canon_dirlen
= strlen (canon_dir
); canon_dirlen
> 0; canon_dirlen
--)
1470 if (IS_DIR_SEPARATOR (canon_dir
[canon_dirlen
- 1]))
1472 canon_dir
[canon_dirlen
] = '\0';
1474 #ifndef EXTRA_DEBUG_ROOT1
1475 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1477 #ifndef EXTRA_DEBUG_ROOT2
1478 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1481 debugfile
= (char *)
1482 bfd_malloc (strlen (debug_file_directory
) + 1
1483 + (canon_dirlen
> dirlen
? canon_dirlen
: dirlen
)
1484 + strlen (".debug/")
1485 #ifdef EXTRA_DEBUG_ROOT1
1486 + strlen (EXTRA_DEBUG_ROOT1
)
1488 #ifdef EXTRA_DEBUG_ROOT2
1489 + strlen (EXTRA_DEBUG_ROOT2
)
1493 if (debugfile
== NULL
)
1494 goto found
; /* Actually this returns NULL. */
1496 /* First try in the same directory as the original file.
1498 FIXME: Strictly speaking if we are using the build-id method,
1499 (ie include_dirs == FALSE) then we should only check absolute
1500 paths, not relative ones like this one (and the next one).
1501 The check is left in however as this allows the binutils
1502 testsuite to exercise this feature without having to install
1503 a file into the root filesystem. (See binutils/testsuite/
1504 binutils-all/objdump.exp for the test). */
1505 sprintf (debugfile
, "%s%s", dir
, base
);
1506 if (check_func (debugfile
, func_data
))
1509 /* Then try in a subdirectory called .debug. */
1510 sprintf (debugfile
, "%s.debug/%s", dir
, base
);
1511 if (check_func (debugfile
, func_data
))
1514 #ifdef EXTRA_DEBUG_ROOT1
1515 /* Try the first extra debug file root. */
1516 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT1
,
1517 include_dirs
? canon_dir
: "/", base
);
1518 if (check_func (debugfile
, func_data
))
1522 #ifdef EXTRA_DEBUG_ROOT2
1523 /* Try the second extra debug file root. */
1524 sprintf (debugfile
, "%s%s%s", EXTRA_DEBUG_ROOT2
,
1525 include_dirs
? canon_dir
: "/", base
);
1526 if (check_func (debugfile
, func_data
))
1530 /* Then try in the global debugfile directory. */
1531 strcpy (debugfile
, debug_file_directory
);
1532 dirlen
= strlen (debug_file_directory
) - 1;
1536 && debug_file_directory
[dirlen
] != '/'
1537 && canon_dir
[0] != '/')
1538 strcat (debugfile
, "/");
1539 strcat (debugfile
, canon_dir
);
1543 if (dirlen
> 0 && debug_file_directory
[dirlen
] != '/')
1544 strcat (debugfile
, "/");
1546 strcat (debugfile
, base
);
1548 if (check_func (debugfile
, func_data
))
1551 /* Failed to find the file. */
1564 bfd_follow_gnu_debuglink
1567 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1570 Takes a BFD and searches it for a .gnu_debuglink section. If this
1571 section is found, it examines the section for the name and checksum
1572 of a '.debug' file containing auxiliary debugging information. It
1573 then searches the filesystem for this .debug file in some standard
1574 locations, including the directory tree rooted at @var{dir}, and if
1575 found returns the full filename.
1577 If @var{dir} is NULL, the search will take place starting at
1578 the current directory.
1581 <<NULL>> on any errors or failure to locate the .debug file,
1582 otherwise a pointer to a heap-allocated string containing the
1583 filename. The caller is responsible for freeing this string.
1587 bfd_follow_gnu_debuglink (bfd
*abfd
, const char *dir
)
1589 unsigned long crc32
;
1591 return find_separate_debug_file (abfd
, dir
, TRUE
,
1592 bfd_get_debug_link_info_1
,
1593 separate_debug_file_exists
, &crc32
);
1596 /* Helper for bfd_follow_gnu_debugaltlink. It just returns the name
1597 of the separate debug file. */
1600 get_alt_debug_link_info_shim (bfd
* abfd
, void *unused ATTRIBUTE_UNUSED
)
1603 bfd_byte
*buildid
= NULL
;
1604 char *result
= bfd_get_alt_debug_link_info (abfd
, &len
, &buildid
);
1613 bfd_follow_gnu_debugaltlink
1616 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1619 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1620 section is found, it examines the section for the name of a file
1621 containing auxiliary debugging information. It then searches the
1622 filesystem for this file in a set of standard locations, including
1623 the directory tree rooted at @var{dir}, and if found returns the
1626 If @var{dir} is NULL, the search will take place starting at
1627 the current directory.
1630 <<NULL>> on any errors or failure to locate the debug file,
1631 otherwise a pointer to a heap-allocated string containing the
1632 filename. The caller is responsible for freeing this string.
1636 bfd_follow_gnu_debugaltlink (bfd
*abfd
, const char *dir
)
1638 return find_separate_debug_file (abfd
, dir
, TRUE
,
1639 get_alt_debug_link_info_shim
,
1640 separate_alt_debug_file_exists
,
1646 bfd_create_gnu_debuglink_section
1649 struct bfd_section *bfd_create_gnu_debuglink_section
1650 (bfd *abfd, const char *filename);
1653 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The
1654 section is sized to be big enough to contain a link to the specified
1658 A pointer to the new section is returned if all is ok. Otherwise
1659 <<NULL>> is returned and bfd_error is set.
1663 bfd_create_gnu_debuglink_section (bfd
*abfd
, const char *filename
)
1666 bfd_size_type debuglink_size
;
1669 if (abfd
== NULL
|| filename
== NULL
)
1671 bfd_set_error (bfd_error_invalid_operation
);
1675 /* Strip off any path components in filename. */
1676 filename
= lbasename (filename
);
1678 sect
= bfd_get_section_by_name (abfd
, GNU_DEBUGLINK
);
1681 /* Section already exists. */
1682 bfd_set_error (bfd_error_invalid_operation
);
1686 flags
= SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_DEBUGGING
;
1687 sect
= bfd_make_section_with_flags (abfd
, GNU_DEBUGLINK
, flags
);
1691 /* Compute the size of the section. Allow for the CRC after the filename,
1692 and padding so that it will start on a 4-byte boundary. */
1693 debuglink_size
= strlen (filename
) + 1;
1694 debuglink_size
+= 3;
1695 debuglink_size
&= ~3;
1696 debuglink_size
+= 4;
1698 if (! bfd_set_section_size (abfd
, sect
, debuglink_size
))
1699 /* XXX Should we delete the section from the bfd ? */
1702 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1703 Note - despite the name of the function being called, we are
1704 setting an alignment power, not a byte alignment value. */
1705 bfd_set_section_alignment (abfd
, sect
, 2);
1713 bfd_fill_in_gnu_debuglink_section
1716 bfd_boolean bfd_fill_in_gnu_debuglink_section
1717 (bfd *abfd, struct bfd_section *sect, const char *filename);
1720 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1721 and fills in the contents of the section to contain a link to the
1722 specified @var{filename}. The filename should be relative to the
1726 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1727 and bfd_error is set.
1731 bfd_fill_in_gnu_debuglink_section (bfd
*abfd
,
1732 struct bfd_section
*sect
,
1733 const char *filename
)
1735 bfd_size_type debuglink_size
;
1736 unsigned long crc32
;
1738 bfd_size_type crc_offset
;
1740 static unsigned char buffer
[8 * 1024];
1744 if (abfd
== NULL
|| sect
== NULL
|| filename
== NULL
)
1746 bfd_set_error (bfd_error_invalid_operation
);
1750 /* Make sure that we can read the file.
1751 XXX - Should we attempt to locate the debug info file using the same
1752 algorithm as gdb ? At the moment, since we are creating the
1753 .gnu_debuglink section, we insist upon the user providing us with a
1754 correct-for-section-creation-time path, but this need not conform to
1755 the gdb location algorithm. */
1756 handle
= _bfd_real_fopen (filename
, FOPEN_RB
);
1759 bfd_set_error (bfd_error_system_call
);
1764 while ((count
= fread (buffer
, 1, sizeof buffer
, handle
)) > 0)
1765 crc32
= bfd_calc_gnu_debuglink_crc32 (crc32
, buffer
, count
);
1768 /* Strip off any path components in filename,
1769 now that we no longer need them. */
1770 filename
= lbasename (filename
);
1772 filelen
= strlen (filename
);
1773 debuglink_size
= filelen
+ 1;
1774 debuglink_size
+= 3;
1775 debuglink_size
&= ~3;
1776 debuglink_size
+= 4;
1778 contents
= (char *) bfd_malloc (debuglink_size
);
1779 if (contents
== NULL
)
1781 /* XXX Should we delete the section from the bfd ? */
1785 crc_offset
= debuglink_size
- 4;
1786 memcpy (contents
, filename
, filelen
);
1787 memset (contents
+ filelen
, 0, crc_offset
- filelen
);
1789 bfd_put_32 (abfd
, crc32
, contents
+ crc_offset
);
1791 if (! bfd_set_section_contents (abfd
, sect
, contents
, 0, debuglink_size
))
1793 /* XXX Should we delete the section from the bfd ? */
1806 struct bfd_build_id * get_build_id (bfd *abfd);
1809 Finds the build-id associated with @var{abfd}. If the build-id is
1810 extracted from the note section then a build-id structure is built
1811 for it, using memory allocated to @var{abfd}, and this is then
1812 attached to the @var{abfd}.
1815 Returns a pointer to the build-id structure if a build-id could be
1816 found. If no build-id is found NULL is returned and error code is
1820 static struct bfd_build_id
*
1821 get_build_id (bfd
*abfd
)
1823 struct bfd_build_id
*build_id
;
1824 Elf_Internal_Note inote
;
1825 Elf_External_Note
*enote
;
1832 if (abfd
->build_id
&& abfd
->build_id
->size
> 0)
1833 /* Save some time by using the already computed build-id. */
1834 return (struct bfd_build_id
*) abfd
->build_id
;
1836 sect
= bfd_get_section_by_name (abfd
, ".note.gnu.build-id");
1839 bfd_set_error (bfd_error_no_debug_section
);
1843 size
= bfd_get_section_size (sect
);
1844 /* FIXME: Should we support smaller build-id notes ? */
1847 bfd_set_error (bfd_error_invalid_operation
);
1851 if (!bfd_malloc_and_get_section (abfd
, sect
, & contents
))
1853 if (contents
!= NULL
)
1858 /* FIXME: Paranoia - allow for compressed build-id sections.
1859 Maybe we should complain if this size is different from
1860 the one obtained above... */
1861 size
= bfd_get_section_size (sect
);
1862 if (size
< sizeof (Elf_External_Note
))
1864 bfd_set_error (bfd_error_invalid_operation
);
1869 enote
= (Elf_External_Note
*) contents
;
1870 inote
.type
= H_GET_32 (abfd
, enote
->type
);
1871 inote
.namesz
= H_GET_32 (abfd
, enote
->namesz
);
1872 inote
.namedata
= enote
->name
;
1873 inote
.descsz
= H_GET_32 (abfd
, enote
->descsz
);
1874 inote
.descdata
= inote
.namedata
+ BFD_ALIGN (inote
.namesz
, 4);
1875 /* FIXME: Should we check for extra notes in this section ? */
1877 if (inote
.descsz
== 0
1878 || inote
.type
!= NT_GNU_BUILD_ID
1879 || inote
.namesz
!= 4 /* sizeof "GNU" */
1880 || strncmp (inote
.namedata
, "GNU", 4) != 0
1881 || size
< (12 + BFD_ALIGN (inote
.namesz
, 4) + inote
.descsz
))
1884 bfd_set_error (bfd_error_invalid_operation
);
1888 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) + inote
.descsz
);
1889 if (build_id
== NULL
)
1895 build_id
->size
= inote
.descsz
;
1896 memcpy (build_id
->data
, inote
.descdata
, inote
.descsz
);
1897 abfd
->build_id
= build_id
;
1908 char * get_build_id_name (bfd *abfd, void *build_id_out_p)
1911 Searches @var{abfd} for a build-id, and then constructs a pathname
1912 from it. The path is computed as .build-id/NN/NN+NN.debug where
1913 NNNN+NN is the build-id value as a hexadecimal string.
1916 Returns the constructed filename or NULL upon error.
1917 It is the caller's responsibility to free the memory used to hold the
1919 If a filename is returned then the @var{build_id_out_p}
1920 parameter (which points to a @code{struct bfd_build_id}
1921 pointer) is set to a pointer to the build_id structure.
1925 get_build_id_name (bfd
*abfd
, void *build_id_out_p
)
1927 struct bfd_build_id
**build_id_out
= build_id_out_p
;
1928 struct bfd_build_id
*build_id
;
1934 if (abfd
== NULL
|| abfd
->filename
== NULL
|| build_id_out
== NULL
)
1936 bfd_set_error (bfd_error_invalid_operation
);
1940 build_id
= get_build_id (abfd
);
1941 if (build_id
== NULL
)
1944 /* Compute the debug pathname corresponding to the build-id. */
1945 name
= bfd_malloc (strlen (".build-id/") + build_id
->size
* 2 + 2 + strlen (".debug"));
1948 bfd_set_error (bfd_error_no_memory
);
1955 n
+= sprintf (n
, ".build-id/");
1956 n
+= sprintf (n
, "%02x", (unsigned) *d
++); s
--;
1957 n
+= sprintf (n
, "/");
1959 n
+= sprintf (n
, "%02x", (unsigned) *d
++);
1960 n
+= sprintf (n
, ".debug");
1962 *build_id_out
= build_id
;
1971 bfd_boolean check_build_id_file (char *name, void *buildid_p);
1974 Checks to see if @var{name} is a readable file and if its build-id
1975 matches @var{buildid}.
1978 Returns TRUE if the file exists, is readable, and contains a
1979 build-id which matches the build-id pointed at by
1980 @var{build_id_p} (which is really a @code{struct bfd_build_id **}).
1984 check_build_id_file (const char *name
, void *buildid_p
)
1986 struct bfd_build_id
*orig_build_id
;
1987 struct bfd_build_id
*build_id
;
1992 BFD_ASSERT (buildid_p
);
1994 file
= bfd_openr (name
, NULL
);
1998 /* If the file is an archive, process all of its elements. */
1999 if (! bfd_check_format (file
, bfd_object
))
2005 build_id
= get_build_id (file
);
2006 if (build_id
== NULL
)
2012 orig_build_id
= *(struct bfd_build_id
**) buildid_p
;
2014 result
= build_id
->size
== orig_build_id
->size
2015 && memcmp (build_id
->data
, orig_build_id
->data
, build_id
->size
) == 0;
2017 (void) bfd_close (file
);
2024 bfd_follow_build_id_debuglink
2027 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
2030 Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2031 If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2032 note, which should be a hexadecimal value @var{NNNN+NN} (for
2033 32+ hex digits). It then searches the filesystem for a file named
2034 @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2035 including the directory tree rooted at @var{dir}. The filename
2036 of the first matching file to be found is returned. A matching
2037 file should contain a .note.gnu.build-id section with the same
2038 @var{NNNN+NN} note as @var{abfd}, although this check is currently
2041 If @var{dir} is NULL, the search will take place starting at
2042 the current directory.
2045 <<NULL>> on any errors or failure to locate the debug file,
2046 otherwise a pointer to a heap-allocated string containing the
2047 filename. The caller is responsible for freeing this string.
2051 bfd_follow_build_id_debuglink (bfd
*abfd
, const char *dir
)
2053 struct bfd_build_id
*build_id
;
2055 return find_separate_debug_file (abfd
, dir
, FALSE
,
2057 check_build_id_file
, &build_id
);