1 /* opncls.c -- open and close a BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
3 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
6 Written by Cygnus Support.
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
28 #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 /* Counter used to initialize the bfd identifier. */
42 static unsigned int _bfd_id_counter = 0;
44 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
45 if we do that we can't use fcntl. */
47 /* Return a new BFD. All BFD's are allocated through this routine. */
54 nbfd = bfd_zmalloc (sizeof (bfd));
58 nbfd->id = _bfd_id_counter++;
60 nbfd->memory = objalloc_create ();
61 if (nbfd->memory == NULL)
63 bfd_set_error (bfd_error_no_memory);
68 nbfd->arch_info = &bfd_default_arch_struct;
70 nbfd->direction = no_direction;
71 nbfd->iostream = NULL;
73 if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
79 nbfd->sections = NULL;
80 nbfd->section_last = NULL;
81 nbfd->format = bfd_unknown;
82 nbfd->my_archive = NULL;
84 nbfd->opened_once = FALSE;
85 nbfd->output_has_begun = FALSE;
86 nbfd->section_count = 0;
88 nbfd->cacheable = FALSE;
89 nbfd->flags = BFD_NO_FLAGS;
90 nbfd->mtime_set = FALSE;
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 nbfd->my_archive = obfd;
108 nbfd->direction = read_direction;
109 nbfd->target_defaulted = obfd->target_defaulted;
116 _bfd_delete_bfd (bfd *abfd)
118 bfd_hash_table_free (&abfd->section_htab);
119 objalloc_free ((struct objalloc *) abfd->memory);
125 Opening and closing BFDs
134 bfd *bfd_fopen (const char *filename, const char *target,
135 const char *mode, int fd);
138 Open the file @var{filename} with the target @var{target}.
139 Return a pointer to the created BFD. If @var{fd} is not -1,
140 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
141 is used. @var{mode} is passed directly to <<fopen>> or
144 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
147 If <<NULL>> is returned then an error has occured. Possible errors
148 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
149 <<system_call>> error.
153 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
156 const bfd_target *target_vec;
158 nbfd = _bfd_new_bfd ();
162 target_vec = bfd_find_target (target, nbfd);
163 if (target_vec == NULL)
165 _bfd_delete_bfd (nbfd);
171 nbfd->iostream = fdopen (fd, mode);
174 nbfd->iostream = fopen (filename, mode);
175 if (nbfd->iostream == NULL)
177 bfd_set_error (bfd_error_system_call);
178 _bfd_delete_bfd (nbfd);
182 /* OK, put everything where it belongs. */
183 nbfd->filename = filename;
185 /* Figure out whether the user is opening the file for reading,
186 writing, or both, by looking at the MODE argument. */
187 if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
189 nbfd->direction = both_direction;
190 else if (mode[0] == 'r')
191 nbfd->direction = read_direction;
193 nbfd->direction = write_direction;
195 if (! bfd_cache_init (nbfd))
197 _bfd_delete_bfd (nbfd);
200 nbfd->opened_once = TRUE;
210 bfd *bfd_openr (const char *filename, const char *target);
213 Open the file @var{filename} (using <<fopen>>) with the target
214 @var{target}. Return a pointer to the created BFD.
216 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
219 If <<NULL>> is returned then an error has occured. Possible errors
220 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
221 <<system_call>> error.
225 bfd_openr (const char *filename, const char *target)
227 return bfd_fopen (filename, target, FOPEN_RB, -1);
230 /* Don't try to `optimize' this function:
232 o - We lock using stack space so that interrupting the locking
233 won't cause a storage leak.
234 o - We open the file stream last, since we don't want to have to
235 close it if anything goes wrong. Closing the stream means closing
236 the file descriptor too, even though we didn't open it. */
242 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
245 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
246 <<fopen>>. It opens a BFD on a file already described by the
249 When the file is later <<bfd_close>>d, the file descriptor will
250 be closed. If the caller desires that this file descriptor be
251 cached by BFD (opened as needed, closed as needed to free
252 descriptors for other opens), with the supplied @var{fd} used as
253 an initial file descriptor (but subject to closure at any time),
254 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
255 is to assume no caching; the file descriptor will remain open
256 until <<bfd_close>>, and will not be affected by BFD operations
259 Possible errors are <<bfd_error_no_memory>>,
260 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
264 bfd_fdopenr (const char *filename, const char *target, int fd)
267 #if defined(HAVE_FCNTL) && defined(F_GETFL)
271 bfd_set_error (bfd_error_system_call);
272 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
273 mode = FOPEN_RUB; /* Assume full access. */
275 fdflags = fcntl (fd, F_GETFL, NULL);
279 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
280 switch (fdflags & (O_ACCMODE))
282 case O_RDONLY: mode = FOPEN_RB; break;
283 case O_WRONLY: mode = FOPEN_RUB; break;
284 case O_RDWR: mode = FOPEN_RUB; break;
289 return bfd_fopen (filename, target, mode, fd);
297 bfd *bfd_openstreamr (const char *, const char *, void *);
301 Open a BFD for read access on an existing stdio stream. When
302 the BFD is passed to <<bfd_close>>, the stream will be closed.
306 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
308 FILE *stream = streamarg;
310 const bfd_target *target_vec;
312 nbfd = _bfd_new_bfd ();
316 target_vec = bfd_find_target (target, nbfd);
317 if (target_vec == NULL)
319 _bfd_delete_bfd (nbfd);
323 nbfd->iostream = stream;
324 nbfd->filename = filename;
325 nbfd->direction = read_direction;
327 if (! bfd_cache_init (nbfd))
329 _bfd_delete_bfd (nbfd);
341 bfd *bfd_openr_iovec (const char *filename, const char *target,
342 void *(*open) (struct bfd *nbfd,
345 file_ptr (*pread) (struct bfd *nbfd,
350 int (*close) (struct bfd *nbfd,
355 Create and return a BFD backed by a read-only @var{stream}.
356 The @var{stream} is created using @var{open}, accessed using
357 @var{pread} and destroyed using @var{close}.
359 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
362 Calls @var{open} (which can call <<bfd_zalloc>> and
363 <<bfd_get_filename>>) to obtain the read-only stream backing
364 the BFD. @var{open} either succeeds returning the
365 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
366 (setting <<bfd_error>>).
368 Calls @var{pread} to request @var{nbytes} of data from
369 @var{stream} starting at @var{offset} (e.g., via a call to
370 <<bfd_read>>). @var{pread} either succeeds returning the
371 number of bytes read (which can be less than @var{nbytes} when
372 end-of-file), or fails returning -1 (setting <<bfd_error>>).
374 Calls @var{close} when the BFD is later closed using
375 <<bfd_close>>. @var{close} either succeeds returning 0, or
376 fails returning -1 (setting <<bfd_error>>).
378 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
379 occurred. Possible errors are <<bfd_error_no_memory>>,
380 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
387 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
388 file_ptr nbytes, file_ptr offset);
389 int (*close) (struct bfd *abfd, void *stream);
394 opncls_btell (struct bfd *abfd)
396 struct opncls *vec = abfd->iostream;
401 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
403 struct opncls *vec = abfd->iostream;
406 case SEEK_SET: vec->where = offset; break;
407 case SEEK_CUR: vec->where += offset; break;
408 case SEEK_END: return -1;
414 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
416 struct opncls *vec = abfd->iostream;
417 file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
425 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
426 const void *where ATTRIBUTE_UNUSED,
427 file_ptr nbytes ATTRIBUTE_UNUSED)
433 opncls_bclose (struct bfd *abfd)
435 struct opncls *vec = abfd->iostream;
436 /* Since the VEC's memory is bound to the bfd deleting the bfd will
439 if (vec->close != NULL)
440 status = (vec->close) (abfd, vec->stream);
441 abfd->iostream = NULL;
446 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
452 opncls_bstat (struct bfd *abfd ATTRIBUTE_UNUSED, struct stat *sb)
454 memset (sb, 0, sizeof (*sb));
458 static const struct bfd_iovec opncls_iovec = {
459 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
460 &opncls_bclose, &opncls_bflush, &opncls_bstat
464 bfd_openr_iovec (const char *filename, const char *target,
465 void *(*open) (struct bfd *nbfd,
468 file_ptr (*pread) (struct bfd *abfd,
473 int (*close) (struct bfd *nbfd,
477 const bfd_target *target_vec;
481 nbfd = _bfd_new_bfd ();
485 target_vec = bfd_find_target (target, nbfd);
486 if (target_vec == NULL)
488 _bfd_delete_bfd (nbfd);
492 nbfd->filename = filename;
493 nbfd->direction = read_direction;
495 stream = open (nbfd, open_closure);
498 _bfd_delete_bfd (nbfd);
502 vec = bfd_zalloc (nbfd, sizeof (struct opncls));
503 vec->stream = stream;
507 nbfd->iovec = &opncls_iovec;
508 nbfd->iostream = vec;
513 /* bfd_openw -- open for writing.
514 Returns a pointer to a freshly-allocated BFD on success, or NULL.
516 See comment by bfd_fdopenr before you try to modify this function. */
523 bfd *bfd_openw (const char *filename, const char *target);
526 Create a BFD, associated with file @var{filename}, using the
527 file format @var{target}, and return a pointer to it.
529 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
530 <<bfd_error_invalid_target>>.
534 bfd_openw (const char *filename, const char *target)
537 const bfd_target *target_vec;
539 /* nbfd has to point to head of malloc'ed block so that bfd_close may
540 reclaim it correctly. */
541 nbfd = _bfd_new_bfd ();
545 target_vec = bfd_find_target (target, nbfd);
546 if (target_vec == NULL)
548 _bfd_delete_bfd (nbfd);
552 nbfd->filename = filename;
553 nbfd->direction = write_direction;
555 if (bfd_open_file (nbfd) == NULL)
557 /* File not writeable, etc. */
558 bfd_set_error (bfd_error_system_call);
559 _bfd_delete_bfd (nbfd);
572 bfd_boolean bfd_close (bfd *abfd);
576 Close a BFD. If the BFD was open for writing, then pending
577 operations are completed and the file written out and closed.
578 If the created file is executable, then <<chmod>> is called
581 All memory attached to the BFD is released.
583 The file descriptor associated with the BFD is closed (even
584 if it was passed in to BFD by <<bfd_fdopenr>>).
587 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
592 bfd_close (bfd *abfd)
596 if (bfd_write_p (abfd))
598 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
602 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
605 /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
607 if (!(abfd->flags & BFD_IN_MEMORY))
608 ret = abfd->iovec->bclose (abfd);
612 /* If the file was open for writing and is now executable,
615 && abfd->direction == write_direction
616 && abfd->flags & EXEC_P)
620 if (stat (abfd->filename, &buf) == 0)
622 unsigned int mask = umask (0);
625 chmod (abfd->filename,
627 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
631 _bfd_delete_bfd (abfd);
641 bfd_boolean bfd_close_all_done (bfd *);
644 Close a BFD. Differs from <<bfd_close>> since it does not
645 complete any pending operations. This routine would be used
646 if the application had just used BFD for swapping and didn't
647 want to use any of the writing code.
649 If the created file is executable, then <<chmod>> is called
652 All memory attached to the BFD is released.
655 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
659 bfd_close_all_done (bfd *abfd)
663 ret = bfd_cache_close (abfd);
665 /* If the file was open for writing and is now executable,
668 && abfd->direction == write_direction
669 && abfd->flags & EXEC_P)
673 if (stat (abfd->filename, &buf) == 0)
675 unsigned int mask = umask (0);
678 chmod (abfd->filename,
680 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
684 _bfd_delete_bfd (abfd);
694 bfd *bfd_create (const char *filename, bfd *templ);
697 Create a new BFD in the manner of <<bfd_openw>>, but without
698 opening a file. The new BFD takes the target from the target
699 used by @var{template}. The format is always set to <<bfd_object>>.
703 bfd_create (const char *filename, bfd *templ)
707 nbfd = _bfd_new_bfd ();
710 nbfd->filename = filename;
712 nbfd->xvec = templ->xvec;
713 nbfd->direction = no_direction;
714 bfd_set_format (nbfd, bfd_object);
724 bfd_boolean bfd_make_writable (bfd *abfd);
727 Takes a BFD as created by <<bfd_create>> and converts it
728 into one like as returned by <<bfd_openw>>. It does this
729 by converting the BFD to BFD_IN_MEMORY. It's assumed that
730 you will call <<bfd_make_readable>> on this bfd later.
733 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
737 bfd_make_writable (bfd *abfd)
739 struct bfd_in_memory *bim;
741 if (abfd->direction != no_direction)
743 bfd_set_error (bfd_error_invalid_operation);
747 bim = bfd_malloc (sizeof (struct bfd_in_memory));
748 abfd->iostream = bim;
749 /* bfd_bwrite will grow these as needed. */
753 abfd->flags |= BFD_IN_MEMORY;
754 abfd->direction = write_direction;
765 bfd_boolean bfd_make_readable (bfd *abfd);
768 Takes a BFD as created by <<bfd_create>> and
769 <<bfd_make_writable>> and converts it into one like as
770 returned by <<bfd_openr>>. It does this by writing the
771 contents out to the memory buffer, then reversing the
775 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
778 bfd_make_readable (bfd *abfd)
780 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
782 bfd_set_error (bfd_error_invalid_operation);
786 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
789 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
793 abfd->arch_info = &bfd_default_arch_struct;
796 abfd->format = bfd_unknown;
797 abfd->my_archive = NULL;
799 abfd->opened_once = FALSE;
800 abfd->output_has_begun = FALSE;
801 abfd->section_count = 0;
802 abfd->usrdata = NULL;
803 abfd->cacheable = FALSE;
804 abfd->flags = BFD_IN_MEMORY;
805 abfd->mtime_set = FALSE;
807 abfd->target_defaulted = TRUE;
808 abfd->direction = read_direction;
811 abfd->outsymbols = 0;
814 bfd_section_list_clear (abfd);
815 bfd_check_format (abfd, bfd_object);
825 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
828 Allocate a block of @var{wanted} bytes of memory attached to
829 <<abfd>> and return a pointer to it.
833 bfd_alloc (bfd *abfd, bfd_size_type size)
837 if (size != (unsigned long) size)
839 bfd_set_error (bfd_error_no_memory);
843 ret = objalloc_alloc (abfd->memory, (unsigned long) size);
845 bfd_set_error (bfd_error_no_memory);
854 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
857 Allocate a block of @var{wanted} bytes of zeroed memory
858 attached to <<abfd>> and return a pointer to it.
862 bfd_zalloc (bfd *abfd, bfd_size_type size)
866 res = bfd_alloc (abfd, size);
868 memset (res, 0, (size_t) size);
872 /* Free a block allocated for a BFD.
873 Note: Also frees all more recently allocated blocks! */
876 bfd_release (bfd *abfd, void *block)
878 objalloc_free_block ((struct objalloc *) abfd->memory, block);
883 GNU Extension: separate debug-info files
885 The idea here is that a special section called .gnu_debuglink might be
886 embedded in a binary file, which indicates that some *other* file
887 contains the real debugging information. This special section contains a
888 filename and CRC32 checksum, which we read and resolve to another file,
891 This facilitates "optional" provision of debugging information, without
892 having to provide two complete copies of every binary object (with and
893 without debug symbols).
896 #define GNU_DEBUGLINK ".gnu_debuglink"
899 bfd_calc_gnu_debuglink_crc32
902 unsigned long bfd_calc_gnu_debuglink_crc32
903 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
906 Computes a CRC value as used in the .gnu_debuglink section.
907 Advances the previously computed @var{crc} value by computing
908 and adding in the crc32 for @var{len} bytes of @var{buf}.
911 Return the updated CRC32 value.
915 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
916 const unsigned char *buf,
919 static const unsigned long crc32_table[256] =
921 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
922 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
923 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
924 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
925 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
926 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
927 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
928 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
929 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
930 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
931 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
932 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
933 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
934 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
935 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
936 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
937 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
938 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
939 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
940 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
941 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
942 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
943 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
944 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
945 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
946 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
947 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
948 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
949 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
950 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
951 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
952 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
953 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
954 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
955 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
956 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
957 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
958 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
959 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
960 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
961 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
962 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
963 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
964 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
965 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
966 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
967 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
968 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
969 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
970 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
971 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
974 const unsigned char *end;
976 crc = ~crc & 0xffffffff;
977 for (end = buf + len; buf < end; ++ buf)
978 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
979 return ~crc & 0xffffffff;;
988 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
991 fetch the filename and CRC32 value for any separate debuginfo
992 associated with @var{abfd}. Return NULL if no such info found,
993 otherwise return filename and update @var{crc32_out}.
997 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1000 unsigned long crc32;
1006 BFD_ASSERT (crc32_out);
1008 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1013 if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1015 if (contents != NULL)
1020 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1021 name = (char *) contents;
1022 crc_offset = strlen (name) + 1;
1023 crc_offset = (crc_offset + 3) & ~3;
1025 crc32 = bfd_get_32 (abfd, contents + crc_offset);
1033 separate_debug_file_exists
1036 bfd_boolean separate_debug_file_exists
1037 (char *name, unsigned long crc32);
1040 Checks to see if @var{name} is a file and if its contents
1045 separate_debug_file_exists (const char *name, const unsigned long crc)
1047 static unsigned char buffer [8 * 1024];
1048 unsigned long file_crc = 0;
1050 bfd_size_type count;
1054 fd = open (name, O_RDONLY);
1058 while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1059 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1063 return crc == file_crc;
1069 find_separate_debug_file
1072 char *find_separate_debug_file (bfd *abfd);
1075 Searches @var{abfd} for a reference to separate debugging
1076 information, scans various locations in the filesystem, including
1077 the file tree rooted at @var{debug_file_directory}, and returns a
1078 filename of such debugging information if the file is found and has
1079 matching CRC32. Returns NULL if no reference to debugging file
1080 exists, or file cannot be found.
1084 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1089 unsigned long crc32;
1093 if (debug_file_directory == NULL)
1094 debug_file_directory = ".";
1096 /* BFD may have been opened from a stream. */
1097 if (! abfd->filename)
1100 basename = get_debug_link_info (abfd, & crc32);
1101 if (basename == NULL)
1104 if (strlen (basename) < 1)
1110 dir = strdup (abfd->filename);
1116 BFD_ASSERT (strlen (dir) != 0);
1118 /* Strip off filename part. */
1119 for (i = strlen (dir) - 1; i >= 0; i--)
1120 if (IS_DIR_SEPARATOR (dir[i]))
1124 BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
1126 debugfile = malloc (strlen (debug_file_directory) + 1
1128 + strlen (".debug/")
1131 if (debugfile == NULL)
1138 /* First try in the same directory as the original file: */
1139 strcpy (debugfile, dir);
1140 strcat (debugfile, basename);
1142 if (separate_debug_file_exists (debugfile, crc32))
1149 /* Then try in a subdirectory called .debug. */
1150 strcpy (debugfile, dir);
1151 strcat (debugfile, ".debug/");
1152 strcat (debugfile, basename);
1154 if (separate_debug_file_exists (debugfile, crc32))
1161 /* Then try in the global debugfile directory. */
1162 strcpy (debugfile, debug_file_directory);
1163 i = strlen (debug_file_directory) - 1;
1165 && debug_file_directory[i] != '/'
1167 strcat (debugfile, "/");
1168 strcat (debugfile, dir);
1169 strcat (debugfile, basename);
1171 if (separate_debug_file_exists (debugfile, crc32))
1187 bfd_follow_gnu_debuglink
1190 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1194 Takes a BFD and searches it for a .gnu_debuglink section. If this
1195 section is found, it examines the section for the name and checksum
1196 of a '.debug' file containing auxiliary debugging information. It
1197 then searches the filesystem for this .debug file in some standard
1198 locations, including the directory tree rooted at @var{dir}, and if
1199 found returns the full filename.
1201 If @var{dir} is NULL, it will search a default path configured into
1202 libbfd at build time. [XXX this feature is not currently
1206 <<NULL>> on any errors or failure to locate the .debug file,
1207 otherwise a pointer to a heap-allocated string containing the
1208 filename. The caller is responsible for freeing this string.
1212 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1214 return find_separate_debug_file (abfd, dir);
1219 bfd_create_gnu_debuglink_section
1222 struct bfd_section *bfd_create_gnu_debuglink_section
1223 (bfd *abfd, const char *filename);
1227 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized
1228 to be big enough to contain a link to the specified @var{filename}.
1231 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is
1232 returned and bfd_error is set.
1236 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1239 bfd_size_type debuglink_size;
1241 if (abfd == NULL || filename == NULL)
1243 bfd_set_error (bfd_error_invalid_operation);
1247 /* Strip off any path components in filename. */
1248 filename = lbasename (filename);
1250 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1253 /* Section already exists. */
1254 bfd_set_error (bfd_error_invalid_operation);
1258 sect = bfd_make_section (abfd, GNU_DEBUGLINK);
1262 if (! bfd_set_section_flags (abfd, sect,
1263 SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING))
1264 /* XXX Should we delete the section from the bfd ? */
1268 debuglink_size = strlen (filename) + 1;
1269 debuglink_size += 3;
1270 debuglink_size &= ~3;
1271 debuglink_size += 4;
1273 if (! bfd_set_section_size (abfd, sect, debuglink_size))
1274 /* XXX Should we delete the section from the bfd ? */
1283 bfd_fill_in_gnu_debuglink_section
1286 bfd_boolean bfd_fill_in_gnu_debuglink_section
1287 (bfd *abfd, struct bfd_section *sect, const char *filename);
1291 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1292 and fills in the contents of the section to contain a link to the
1293 specified @var{filename}. The filename should be relative to the
1297 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1298 and bfd_error is set.
1302 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1303 struct bfd_section *sect,
1304 const char *filename)
1306 bfd_size_type debuglink_size;
1307 unsigned long crc32;
1309 bfd_size_type crc_offset;
1311 static unsigned char buffer[8 * 1024];
1314 if (abfd == NULL || sect == NULL || filename == NULL)
1316 bfd_set_error (bfd_error_invalid_operation);
1320 /* Make sure that we can read the file.
1321 XXX - Should we attempt to locate the debug info file using the same
1322 algorithm as gdb ? At the moment, since we are creating the
1323 .gnu_debuglink section, we insist upon the user providing us with a
1324 correct-for-section-creation-time path, but this need not conform to
1325 the gdb location algorithm. */
1326 handle = fopen (filename, FOPEN_RB);
1329 bfd_set_error (bfd_error_system_call);
1334 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1335 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1338 /* Strip off any path components in filename,
1339 now that we no longer need them. */
1340 filename = lbasename (filename);
1342 debuglink_size = strlen (filename) + 1;
1343 debuglink_size += 3;
1344 debuglink_size &= ~3;
1345 debuglink_size += 4;
1347 contents = malloc (debuglink_size);
1348 if (contents == NULL)
1350 /* XXX Should we delete the section from the bfd ? */
1351 bfd_set_error (bfd_error_no_memory);
1355 strcpy (contents, filename);
1356 crc_offset = debuglink_size - 4;
1358 bfd_put_32 (abfd, crc32, contents + crc_offset);
1360 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1362 /* XXX Should we delete the section from the bfd ? */