1 /* opncls.c -- open and close a BFD.
2 Copyright 1990-2013 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"
30 #define S_IXUSR 0100 /* Execute by owner. */
33 #define S_IXGRP 0010 /* Execute by group. */
36 #define S_IXOTH 0001 /* Execute by others. */
39 /* Counters used to initialize the bfd identifier. */
41 static unsigned int bfd_id_counter = 0;
42 static unsigned int bfd_reserved_id_counter = 0;
46 .{* Set to N to open the next N BFDs using an alternate id space. *}
47 .extern unsigned int bfd_use_reserved_id;
49 unsigned int bfd_use_reserved_id = 0;
51 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
52 if we do that we can't use fcntl. */
54 /* Return a new BFD. All BFD's are allocated through this routine. */
61 nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
65 if (bfd_use_reserved_id)
67 nbfd->id = --bfd_reserved_id_counter;
68 --bfd_use_reserved_id;
71 nbfd->id = bfd_id_counter++;
73 nbfd->memory = objalloc_create ();
74 if (nbfd->memory == NULL)
76 bfd_set_error (bfd_error_no_memory);
81 nbfd->arch_info = &bfd_default_arch_struct;
83 if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
84 sizeof (struct section_hash_entry), 13))
93 static const struct bfd_iovec opncls_iovec;
95 /* Allocate a new BFD as a member of archive OBFD. */
98 _bfd_new_bfd_contained_in (bfd *obfd)
102 nbfd = _bfd_new_bfd ();
105 nbfd->xvec = obfd->xvec;
106 nbfd->iovec = obfd->iovec;
107 if (obfd->iovec == &opncls_iovec)
108 nbfd->iostream = obfd->iostream;
109 nbfd->my_archive = obfd;
110 nbfd->direction = read_direction;
111 nbfd->target_defaulted = obfd->target_defaulted;
118 _bfd_delete_bfd (bfd *abfd)
122 bfd_hash_table_free (&abfd->section_htab);
123 objalloc_free ((struct objalloc *) abfd->memory);
126 free (abfd->arelt_data);
130 /* Free objalloc memory. */
133 _bfd_free_cached_info (bfd *abfd)
137 bfd_hash_table_free (&abfd->section_htab);
138 objalloc_free ((struct objalloc *) abfd->memory);
140 abfd->sections = NULL;
141 abfd->section_last = NULL;
142 abfd->outsymbols = NULL;
143 abfd->tdata.any = NULL;
144 abfd->usrdata = NULL;
153 Opening and closing BFDs
156 Functions for opening and closing
164 bfd *bfd_fopen (const char *filename, const char *target,
165 const char *mode, int fd);
168 Open the file @var{filename} with the target @var{target}.
169 Return a pointer to the created BFD. If @var{fd} is not -1,
170 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
171 is used. @var{mode} is passed directly to <<fopen>> or
174 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
177 The new BFD is marked as cacheable iff @var{fd} is -1.
179 If <<NULL>> is returned then an error has occured. Possible errors
180 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
181 <<system_call>> error.
183 On error, @var{fd} is always closed.
187 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
190 const bfd_target *target_vec;
192 nbfd = _bfd_new_bfd ();
200 target_vec = bfd_find_target (target, nbfd);
201 if (target_vec == NULL)
205 _bfd_delete_bfd (nbfd);
211 nbfd->iostream = fdopen (fd, mode);
214 nbfd->iostream = real_fopen (filename, mode);
215 if (nbfd->iostream == NULL)
217 bfd_set_error (bfd_error_system_call);
218 _bfd_delete_bfd (nbfd);
222 /* OK, put everything where it belongs. */
223 nbfd->filename = filename;
225 /* Figure out whether the user is opening the file for reading,
226 writing, or both, by looking at the MODE argument. */
227 if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
229 nbfd->direction = both_direction;
230 else if (mode[0] == 'r')
231 nbfd->direction = read_direction;
233 nbfd->direction = write_direction;
235 if (! bfd_cache_init (nbfd))
237 _bfd_delete_bfd (nbfd);
240 nbfd->opened_once = TRUE;
242 /* If we opened the file by name, mark it cacheable; we can close it
243 and reopen it later. However, if a file descriptor was provided,
244 then it may have been opened with special flags that make it
245 unsafe to close and reopen the file. */
247 (void) bfd_set_cacheable (nbfd, TRUE);
257 bfd *bfd_openr (const char *filename, const char *target);
260 Open the file @var{filename} (using <<fopen>>) with the target
261 @var{target}. Return a pointer to the created BFD.
263 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
266 If <<NULL>> is returned then an error has occured. Possible errors
267 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
268 <<system_call>> error.
272 bfd_openr (const char *filename, const char *target)
274 return bfd_fopen (filename, target, FOPEN_RB, -1);
277 /* Don't try to `optimize' this function:
279 o - We lock using stack space so that interrupting the locking
280 won't cause a storage leak.
281 o - We open the file stream last, since we don't want to have to
282 close it if anything goes wrong. Closing the stream means closing
283 the file descriptor too, even though we didn't open it. */
289 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
292 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
293 <<fopen>>. It opens a BFD on a file already described by the
296 When the file is later <<bfd_close>>d, the file descriptor will
297 be closed. If the caller desires that this file descriptor be
298 cached by BFD (opened as needed, closed as needed to free
299 descriptors for other opens), with the supplied @var{fd} used as
300 an initial file descriptor (but subject to closure at any time),
301 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
302 is to assume no caching; the file descriptor will remain open
303 until <<bfd_close>>, and will not be affected by BFD operations
306 Possible errors are <<bfd_error_no_memory>>,
307 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
309 On error, @var{fd} is closed.
313 bfd_fdopenr (const char *filename, const char *target, int fd)
316 #if defined(HAVE_FCNTL) && defined(F_GETFL)
320 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
321 mode = FOPEN_RUB; /* Assume full access. */
323 fdflags = fcntl (fd, F_GETFL, NULL);
330 bfd_set_error (bfd_error_system_call);
334 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
335 switch (fdflags & (O_ACCMODE))
337 case O_RDONLY: mode = FOPEN_RB; break;
338 case O_WRONLY: mode = FOPEN_RUB; break;
339 case O_RDWR: mode = FOPEN_RUB; break;
344 return bfd_fopen (filename, target, mode, fd);
352 bfd *bfd_openstreamr (const char *, const char *, void *);
356 Open a BFD for read access on an existing stdio stream. When
357 the BFD is passed to <<bfd_close>>, the stream will be closed.
361 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
363 FILE *stream = (FILE *) streamarg;
365 const bfd_target *target_vec;
367 nbfd = _bfd_new_bfd ();
371 target_vec = bfd_find_target (target, nbfd);
372 if (target_vec == NULL)
374 _bfd_delete_bfd (nbfd);
378 nbfd->iostream = stream;
379 nbfd->filename = filename;
380 nbfd->direction = read_direction;
382 if (! bfd_cache_init (nbfd))
384 _bfd_delete_bfd (nbfd);
396 bfd *bfd_openr_iovec (const char *filename, const char *target,
397 void *(*open_func) (struct bfd *nbfd,
400 file_ptr (*pread_func) (struct bfd *nbfd,
405 int (*close_func) (struct bfd *nbfd,
407 int (*stat_func) (struct bfd *abfd,
413 Create and return a BFD backed by a read-only @var{stream}.
414 The @var{stream} is created using @var{open_func}, accessed using
415 @var{pread_func} and destroyed using @var{close_func}.
417 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
420 Calls @var{open_func} (which can call <<bfd_zalloc>> and
421 <<bfd_get_filename>>) to obtain the read-only stream backing
422 the BFD. @var{open_func} either succeeds returning the
423 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
424 (setting <<bfd_error>>).
426 Calls @var{pread_func} to request @var{nbytes} of data from
427 @var{stream} starting at @var{offset} (e.g., via a call to
428 <<bfd_read>>). @var{pread_func} either succeeds returning the
429 number of bytes read (which can be less than @var{nbytes} when
430 end-of-file), or fails returning -1 (setting <<bfd_error>>).
432 Calls @var{close_func} when the BFD is later closed using
433 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
434 fails returning -1 (setting <<bfd_error>>).
436 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
437 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
438 on success, or returns -1 on failure (setting <<bfd_error>>).
440 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
441 occurred. Possible errors are <<bfd_error_no_memory>>,
442 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
449 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
450 file_ptr nbytes, file_ptr offset);
451 int (*close) (struct bfd *abfd, void *stream);
452 int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
457 opncls_btell (struct bfd *abfd)
459 struct opncls *vec = (struct opncls *) abfd->iostream;
464 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
466 struct opncls *vec = (struct opncls *) abfd->iostream;
469 case SEEK_SET: vec->where = offset; break;
470 case SEEK_CUR: vec->where += offset; break;
471 case SEEK_END: return -1;
477 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
479 struct opncls *vec = (struct opncls *) abfd->iostream;
480 file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
488 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
489 const void *where ATTRIBUTE_UNUSED,
490 file_ptr nbytes ATTRIBUTE_UNUSED)
496 opncls_bclose (struct bfd *abfd)
498 struct opncls *vec = (struct opncls *) abfd->iostream;
499 /* Since the VEC's memory is bound to the bfd deleting the bfd will
502 if (vec->close != NULL)
503 status = (vec->close) (abfd, vec->stream);
504 abfd->iostream = NULL;
509 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
515 opncls_bstat (struct bfd *abfd, struct stat *sb)
517 struct opncls *vec = (struct opncls *) abfd->iostream;
519 memset (sb, 0, sizeof (*sb));
520 if (vec->stat == NULL)
523 return (vec->stat) (abfd, vec->stream, sb);
527 opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
528 void *addr ATTRIBUTE_UNUSED,
529 bfd_size_type len ATTRIBUTE_UNUSED,
530 int prot ATTRIBUTE_UNUSED,
531 int flags ATTRIBUTE_UNUSED,
532 file_ptr offset ATTRIBUTE_UNUSED,
533 void **map_addr ATTRIBUTE_UNUSED,
534 bfd_size_type *map_len ATTRIBUTE_UNUSED)
539 static const struct bfd_iovec opncls_iovec = {
540 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
541 &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
545 bfd_openr_iovec (const char *filename, const char *target,
546 void *(*open_p) (struct bfd *, void *),
548 file_ptr (*pread_p) (struct bfd *, void *, void *,
550 int (*close_p) (struct bfd *, void *),
551 int (*stat_p) (struct bfd *, void *, struct stat *))
554 const bfd_target *target_vec;
558 nbfd = _bfd_new_bfd ();
562 target_vec = bfd_find_target (target, nbfd);
563 if (target_vec == NULL)
565 _bfd_delete_bfd (nbfd);
569 nbfd->filename = filename;
570 nbfd->direction = read_direction;
572 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
573 stream = (*open_p) (nbfd, open_closure);
576 _bfd_delete_bfd (nbfd);
580 vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));
581 vec->stream = stream;
582 vec->pread = pread_p;
583 vec->close = close_p;
586 nbfd->iovec = &opncls_iovec;
587 nbfd->iostream = vec;
592 /* bfd_openw -- open for writing.
593 Returns a pointer to a freshly-allocated BFD on success, or NULL.
595 See comment by bfd_fdopenr before you try to modify this function. */
602 bfd *bfd_openw (const char *filename, const char *target);
605 Create a BFD, associated with file @var{filename}, using the
606 file format @var{target}, and return a pointer to it.
608 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
609 <<bfd_error_invalid_target>>.
613 bfd_openw (const char *filename, const char *target)
616 const bfd_target *target_vec;
618 /* nbfd has to point to head of malloc'ed block so that bfd_close may
619 reclaim it correctly. */
620 nbfd = _bfd_new_bfd ();
624 target_vec = bfd_find_target (target, nbfd);
625 if (target_vec == NULL)
627 _bfd_delete_bfd (nbfd);
631 nbfd->filename = filename;
632 nbfd->direction = write_direction;
634 if (bfd_open_file (nbfd) == NULL)
636 /* File not writeable, etc. */
637 bfd_set_error (bfd_error_system_call);
638 _bfd_delete_bfd (nbfd);
646 _maybe_make_executable (bfd * abfd)
648 /* If the file was open for writing and is now executable,
650 if (abfd->direction == write_direction
651 && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)
655 if (stat (abfd->filename, &buf) == 0
656 /* Do not attempt to change non-regular files. This is
657 here especially for configure scripts and kernel builds
658 which run tests with "ld [...] -o /dev/null". */
659 && S_ISREG(buf.st_mode))
661 unsigned int mask = umask (0);
664 chmod (abfd->filename,
666 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
677 bfd_boolean bfd_close (bfd *abfd);
681 Close a BFD. If the BFD was open for writing, then pending
682 operations are completed and the file written out and closed.
683 If the created file is executable, then <<chmod>> is called
686 All memory attached to the BFD is released.
688 The file descriptor associated with the BFD is closed (even
689 if it was passed in to BFD by <<bfd_fdopenr>>).
692 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
697 bfd_close (bfd *abfd)
701 if (bfd_write_p (abfd))
703 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
707 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
710 ret = abfd->iovec->bclose (abfd) == 0;
713 _maybe_make_executable (abfd);
715 _bfd_delete_bfd (abfd);
725 bfd_boolean bfd_close_all_done (bfd *);
728 Close a BFD. Differs from <<bfd_close>> since it does not
729 complete any pending operations. This routine would be used
730 if the application had just used BFD for swapping and didn't
731 want to use any of the writing code.
733 If the created file is executable, then <<chmod>> is called
736 All memory attached to the BFD is released.
739 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
743 bfd_close_all_done (bfd *abfd)
747 ret = bfd_cache_close (abfd);
750 _maybe_make_executable (abfd);
752 _bfd_delete_bfd (abfd);
762 bfd *bfd_create (const char *filename, bfd *templ);
765 Create a new BFD in the manner of <<bfd_openw>>, but without
766 opening a file. The new BFD takes the target from the target
767 used by @var{templ}. The format is always set to <<bfd_object>>.
771 bfd_create (const char *filename, bfd *templ)
775 nbfd = _bfd_new_bfd ();
778 nbfd->filename = filename;
780 nbfd->xvec = templ->xvec;
781 nbfd->direction = no_direction;
782 bfd_set_format (nbfd, bfd_object);
792 bfd_boolean bfd_make_writable (bfd *abfd);
795 Takes a BFD as created by <<bfd_create>> and converts it
796 into one like as returned by <<bfd_openw>>. It does this
797 by converting the BFD to BFD_IN_MEMORY. It's assumed that
798 you will call <<bfd_make_readable>> on this bfd later.
801 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
805 bfd_make_writable (bfd *abfd)
807 struct bfd_in_memory *bim;
809 if (abfd->direction != no_direction)
811 bfd_set_error (bfd_error_invalid_operation);
815 bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
817 return FALSE; /* bfd_error already set. */
818 abfd->iostream = bim;
819 /* bfd_bwrite will grow these as needed. */
823 abfd->flags |= BFD_IN_MEMORY;
824 abfd->iovec = &_bfd_memory_iovec;
826 abfd->direction = write_direction;
837 bfd_boolean bfd_make_readable (bfd *abfd);
840 Takes a BFD as created by <<bfd_create>> and
841 <<bfd_make_writable>> and converts it into one like as
842 returned by <<bfd_openr>>. It does this by writing the
843 contents out to the memory buffer, then reversing the
847 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
850 bfd_make_readable (bfd *abfd)
852 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
854 bfd_set_error (bfd_error_invalid_operation);
858 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
861 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
864 abfd->arch_info = &bfd_default_arch_struct;
867 abfd->format = bfd_unknown;
868 abfd->my_archive = NULL;
870 abfd->opened_once = FALSE;
871 abfd->output_has_begun = FALSE;
872 abfd->section_count = 0;
873 abfd->usrdata = NULL;
874 abfd->cacheable = FALSE;
875 abfd->flags |= BFD_IN_MEMORY;
876 abfd->mtime_set = FALSE;
878 abfd->target_defaulted = TRUE;
879 abfd->direction = read_direction;
882 abfd->outsymbols = 0;
885 bfd_section_list_clear (abfd);
886 bfd_check_format (abfd, bfd_object);
896 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
899 Allocate a block of @var{wanted} bytes of memory attached to
900 <<abfd>> and return a pointer to it.
904 bfd_alloc (bfd *abfd, bfd_size_type size)
908 if (size != (unsigned long) size)
910 bfd_set_error (bfd_error_no_memory);
914 ret = objalloc_alloc ((struct objalloc *) abfd->memory, (unsigned long) size);
916 bfd_set_error (bfd_error_no_memory);
925 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
928 Allocate a block of @var{nmemb} elements of @var{size} bytes each
929 of memory attached to <<abfd>> and return a pointer to it.
933 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
937 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
939 && nmemb > ~(bfd_size_type) 0 / size)
941 bfd_set_error (bfd_error_no_memory);
947 if (size != (unsigned long) size)
949 bfd_set_error (bfd_error_no_memory);
953 ret = objalloc_alloc ((struct objalloc *) abfd->memory, (unsigned long) size);
955 bfd_set_error (bfd_error_no_memory);
964 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
967 Allocate a block of @var{wanted} bytes of zeroed memory
968 attached to <<abfd>> and return a pointer to it.
972 bfd_zalloc (bfd *abfd, bfd_size_type size)
976 res = bfd_alloc (abfd, size);
978 memset (res, 0, (size_t) size);
987 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
990 Allocate a block of @var{nmemb} elements of @var{size} bytes each
991 of zeroed memory attached to <<abfd>> and return a pointer to it.
995 bfd_zalloc2 (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);
1009 res = bfd_alloc (abfd, size);
1011 memset (res, 0, (size_t) size);
1015 /* Free a block allocated for a BFD.
1016 Note: Also frees all more recently allocated blocks! */
1019 bfd_release (bfd *abfd, void *block)
1021 objalloc_free_block ((struct objalloc *) abfd->memory, block);
1026 GNU Extension: separate debug-info files
1028 The idea here is that a special section called .gnu_debuglink might be
1029 embedded in a binary file, which indicates that some *other* file
1030 contains the real debugging information. This special section contains a
1031 filename and CRC32 checksum, which we read and resolve to another file,
1034 This facilitates "optional" provision of debugging information, without
1035 having to provide two complete copies of every binary object (with and
1036 without debug symbols). */
1038 #define GNU_DEBUGLINK ".gnu_debuglink"
1039 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1043 bfd_calc_gnu_debuglink_crc32
1046 unsigned long bfd_calc_gnu_debuglink_crc32
1047 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1050 Computes a CRC value as used in the .gnu_debuglink section.
1051 Advances the previously computed @var{crc} value by computing
1052 and adding in the crc32 for @var{len} bytes of @var{buf}.
1055 Return the updated CRC32 value.
1059 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1060 const unsigned char *buf,
1063 static const unsigned long crc32_table[256] =
1065 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1066 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1067 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1068 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1069 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1070 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1071 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1072 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1073 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1074 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1075 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1076 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1077 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1078 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1079 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1080 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1081 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1082 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1083 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1084 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1085 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1086 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1087 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1088 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1089 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1090 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1091 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1092 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1093 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1094 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1095 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1096 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1097 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1098 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1099 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1100 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1101 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1102 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1103 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1104 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1105 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1106 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1107 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1108 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1109 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1110 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1111 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1112 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1113 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1114 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1115 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1118 const unsigned char *end;
1120 crc = ~crc & 0xffffffff;
1121 for (end = buf + len; buf < end; ++ buf)
1122 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1123 return ~crc & 0xffffffff;
1129 bfd_get_debug_link_info
1132 char *bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1135 fetch the filename and CRC32 value for any separate debuginfo
1136 associated with @var{abfd}. Return NULL if no such info found,
1137 otherwise return filename and update @var{crc32_out}. The
1138 returned filename is allocated with @code{malloc}; freeing it
1139 is the responsibility of the caller.
1143 bfd_get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1146 unsigned long crc32;
1152 BFD_ASSERT (crc32_out);
1154 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1159 if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1161 if (contents != NULL)
1166 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1167 name = (char *) contents;
1168 crc_offset = strlen (name) + 1;
1169 crc_offset = (crc_offset + 3) & ~3;
1171 crc32 = bfd_get_32 (abfd, contents + crc_offset);
1179 bfd_get_alt_debug_link_info
1182 char *bfd_get_alt_debug_link_info (bfd * abfd,
1183 bfd_size_type *buildid_len,
1184 bfd_byte **buildid_out);
1187 Fetch the filename and BuildID value for any alternate debuginfo
1188 associated with @var{abfd}. Return NULL if no such info found,
1189 otherwise return filename and update @var{buildid_len} and
1190 @var{buildid_out}. The returned filename and build_id are
1191 allocated with @code{malloc}; freeing them is the
1192 responsibility of the caller.
1196 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1197 bfd_byte **buildid_out)
1205 BFD_ASSERT (buildid_len);
1206 BFD_ASSERT (buildid_out);
1208 sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1213 if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1215 if (contents != NULL)
1220 /* BuildID value is stored after the filename. */
1221 name = (char *) contents;
1222 buildid_offset = strlen (name) + 1;
1224 *buildid_len = bfd_get_section_size (sect) - buildid_offset;
1225 *buildid_out = bfd_malloc (*buildid_len);
1226 memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1233 separate_debug_file_exists
1236 bfd_boolean separate_debug_file_exists
1237 (char *name, unsigned long crc32);
1240 Checks to see if @var{name} is a file and if its contents
1245 separate_debug_file_exists (const char *name, const unsigned long crc)
1247 static unsigned char buffer [8 * 1024];
1248 unsigned long file_crc = 0;
1250 bfd_size_type count;
1254 f = real_fopen (name, FOPEN_RB);
1258 while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1259 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1263 return crc == file_crc;
1268 separate_alt_debug_file_exists
1271 bfd_boolean separate_alt_debug_file_exists
1272 (char *name, unsigned long crc32);
1275 Checks to see if @var{name} is a file and if its BuildID
1276 matches @var{buildid}.
1280 separate_alt_debug_file_exists (const char *name,
1281 const unsigned long buildid ATTRIBUTE_UNUSED)
1287 f = real_fopen (name, FOPEN_RB);
1291 /* FIXME: Add code to check buildid. */
1300 find_separate_debug_file
1303 char *find_separate_debug_file (bfd *abfd);
1306 Searches @var{abfd} for a section called @var{section_name} which
1307 is expected to contain a reference to a file containing separate
1308 debugging information. The function scans various locations in
1309 the filesystem, including the file tree rooted at
1310 @var{debug_file_directory}, and returns the first matching
1311 filename that it finds. If @var{check_crc} is TRUE then the
1312 contents of the file must also match the CRC value contained in
1313 @var{section_name}. Returns NULL if no valid file could be found.
1316 typedef char * (* get_func_type) (bfd *, unsigned long *);
1317 typedef bfd_boolean (* check_func_type) (const char *, const unsigned long);
1320 find_separate_debug_file (bfd * abfd,
1321 const char * debug_file_directory,
1322 get_func_type get_func,
1323 check_func_type check_func)
1329 unsigned long crc32;
1331 size_t canon_dirlen;
1334 if (debug_file_directory == NULL)
1335 debug_file_directory = ".";
1337 /* BFD may have been opened from a stream. */
1338 if (abfd->filename == NULL)
1340 bfd_set_error (bfd_error_invalid_operation);
1344 base = get_func (abfd, & crc32);
1349 if (base[0] == '\0')
1352 bfd_set_error (bfd_error_no_debug_section);
1356 for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1357 if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1360 dir = (char *) bfd_malloc (dirlen + 1);
1366 memcpy (dir, abfd->filename, dirlen);
1369 /* Compute the canonical name of the bfd object with all symbolic links
1370 resolved, for use in the global debugfile directory. */
1371 canon_dir = lrealpath (abfd->filename);
1372 for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1373 if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1375 canon_dir[canon_dirlen] = '\0';
1377 debugfile = (char *)
1378 bfd_malloc (strlen (debug_file_directory) + 1
1379 + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1380 + strlen (".debug/")
1383 if (debugfile == NULL)
1384 goto found; /* Actually this returns NULL. */
1386 /* First try in the same directory as the original file: */
1387 strcpy (debugfile, dir);
1388 strcat (debugfile, base);
1390 if (check_func (debugfile, crc32))
1393 /* Then try in a subdirectory called .debug. */
1394 strcpy (debugfile, dir);
1395 strcat (debugfile, ".debug/");
1396 strcat (debugfile, base);
1398 if (check_func (debugfile, crc32))
1401 /* Then try in the global debugfile directory. */
1402 strcpy (debugfile, debug_file_directory);
1403 dirlen = strlen (debug_file_directory) - 1;
1405 && debug_file_directory[dirlen] != '/'
1406 && canon_dir[0] != '/')
1407 strcat (debugfile, "/");
1408 strcat (debugfile, canon_dir);
1409 strcat (debugfile, base);
1411 if (check_func (debugfile, crc32))
1414 /* Failed to find the file. */
1428 bfd_follow_gnu_debuglink
1431 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1435 Takes a BFD and searches it for a .gnu_debuglink section. If this
1436 section is found, it examines the section for the name and checksum
1437 of a '.debug' file containing auxiliary debugging information. It
1438 then searches the filesystem for this .debug file in some standard
1439 locations, including the directory tree rooted at @var{dir}, and if
1440 found returns the full filename.
1442 If @var{dir} is NULL, it will search a default path configured into
1443 libbfd at build time. [XXX this feature is not currently
1447 <<NULL>> on any errors or failure to locate the .debug file,
1448 otherwise a pointer to a heap-allocated string containing the
1449 filename. The caller is responsible for freeing this string.
1453 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1455 return find_separate_debug_file (abfd, dir,
1456 bfd_get_debug_link_info,
1457 separate_debug_file_exists);
1460 /* Helper for bfd_follow_gnu_debugaltlink. It just pretends to return
1461 a CRC. .gnu_debugaltlink supplies a build-id, which is different,
1462 but this is ok because separate_alt_debug_file_exists ignores the
1466 get_alt_debug_link_info_shim (bfd * abfd, unsigned long *crc32_out)
1469 bfd_byte *buildid = NULL;
1470 char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1480 bfd_follow_gnu_debugaltlink
1483 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1487 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1488 section is found, it examines the section for the name of a file
1489 containing auxiliary debugging information. It then searches the
1490 filesystem for this file in a set of standard locations, including
1491 the directory tree rooted at @var{dir}, and if found returns the
1494 If @var{dir} is NULL, it will search a default path configured into
1495 libbfd at build time. [FIXME: This feature is not currently
1499 <<NULL>> on any errors or failure to locate the debug file,
1500 otherwise a pointer to a heap-allocated string containing the
1501 filename. The caller is responsible for freeing this string.
1505 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1507 return find_separate_debug_file (abfd, dir,
1508 get_alt_debug_link_info_shim,
1509 separate_alt_debug_file_exists);
1514 bfd_create_gnu_debuglink_section
1517 struct bfd_section *bfd_create_gnu_debuglink_section
1518 (bfd *abfd, const char *filename);
1522 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized
1523 to be big enough to contain a link to the specified @var{filename}.
1526 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is
1527 returned and bfd_error is set.
1531 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1534 bfd_size_type debuglink_size;
1537 if (abfd == NULL || filename == NULL)
1539 bfd_set_error (bfd_error_invalid_operation);
1543 /* Strip off any path components in filename. */
1544 filename = lbasename (filename);
1546 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1549 /* Section already exists. */
1550 bfd_set_error (bfd_error_invalid_operation);
1554 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1555 sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1559 debuglink_size = strlen (filename) + 1;
1560 debuglink_size += 3;
1561 debuglink_size &= ~3;
1562 debuglink_size += 4;
1564 if (! bfd_set_section_size (abfd, sect, debuglink_size))
1565 /* XXX Should we delete the section from the bfd ? */
1574 bfd_fill_in_gnu_debuglink_section
1577 bfd_boolean bfd_fill_in_gnu_debuglink_section
1578 (bfd *abfd, struct bfd_section *sect, const char *filename);
1582 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1583 and fills in the contents of the section to contain a link to the
1584 specified @var{filename}. The filename should be relative to the
1588 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1589 and bfd_error is set.
1593 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1594 struct bfd_section *sect,
1595 const char *filename)
1597 bfd_size_type debuglink_size;
1598 unsigned long crc32;
1600 bfd_size_type crc_offset;
1602 static unsigned char buffer[8 * 1024];
1606 if (abfd == NULL || sect == NULL || filename == NULL)
1608 bfd_set_error (bfd_error_invalid_operation);
1612 /* Make sure that we can read the file.
1613 XXX - Should we attempt to locate the debug info file using the same
1614 algorithm as gdb ? At the moment, since we are creating the
1615 .gnu_debuglink section, we insist upon the user providing us with a
1616 correct-for-section-creation-time path, but this need not conform to
1617 the gdb location algorithm. */
1618 handle = real_fopen (filename, FOPEN_RB);
1621 bfd_set_error (bfd_error_system_call);
1626 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1627 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1630 /* Strip off any path components in filename,
1631 now that we no longer need them. */
1632 filename = lbasename (filename);
1634 filelen = strlen (filename);
1635 debuglink_size = filelen + 1;
1636 debuglink_size += 3;
1637 debuglink_size &= ~3;
1638 debuglink_size += 4;
1640 contents = (char *) bfd_malloc (debuglink_size);
1641 if (contents == NULL)
1643 /* XXX Should we delete the section from the bfd ? */
1647 crc_offset = debuglink_size - 4;
1648 memcpy (contents, filename, filelen);
1649 memset (contents + filelen, 0, crc_offset - filelen);
1651 bfd_put_32 (abfd, crc32, contents + crc_offset);
1653 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1655 /* XXX Should we delete the section from the bfd ? */