merge from gcc
[binutils.git] / bfd / opncls.c
blob6abd40509ca2af4e0791ac2f693cc4b95e76bc91
1 /* opncls.c -- open and close a BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
3 2001, 2002, 2003
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "objalloc.h"
27 #include "libbfd.h"
28 #include "libiberty.h"
30 #ifndef S_IXUSR
31 #define S_IXUSR 0100 /* Execute by owner. */
32 #endif
33 #ifndef S_IXGRP
34 #define S_IXGRP 0010 /* Execute by group. */
35 #endif
36 #ifndef S_IXOTH
37 #define S_IXOTH 0001 /* Execute by others. */
38 #endif
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. */
49 bfd *
50 _bfd_new_bfd (void)
52 bfd *nbfd;
54 nbfd = bfd_zmalloc (sizeof (bfd));
55 if (nbfd == NULL)
56 return NULL;
58 nbfd->id = _bfd_id_counter++;
60 nbfd->memory = objalloc_create ();
61 if (nbfd->memory == NULL)
63 bfd_set_error (bfd_error_no_memory);
64 free (nbfd);
65 return NULL;
68 nbfd->arch_info = &bfd_default_arch_struct;
70 nbfd->direction = no_direction;
71 nbfd->iostream = NULL;
72 nbfd->where = 0;
73 if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
74 251))
76 free (nbfd);
77 return NULL;
79 nbfd->sections = NULL;
80 nbfd->section_tail = &nbfd->sections;
81 nbfd->format = bfd_unknown;
82 nbfd->my_archive = NULL;
83 nbfd->origin = 0;
84 nbfd->opened_once = FALSE;
85 nbfd->output_has_begun = FALSE;
86 nbfd->section_count = 0;
87 nbfd->usrdata = NULL;
88 nbfd->cacheable = FALSE;
89 nbfd->flags = BFD_NO_FLAGS;
90 nbfd->mtime_set = FALSE;
92 return nbfd;
95 /* Allocate a new BFD as a member of archive OBFD. */
97 bfd *
98 _bfd_new_bfd_contained_in (bfd *obfd)
100 bfd *nbfd;
102 nbfd = _bfd_new_bfd ();
103 if (nbfd == NULL)
104 return NULL;
105 nbfd->xvec = obfd->xvec;
106 nbfd->my_archive = obfd;
107 nbfd->direction = read_direction;
108 nbfd->target_defaulted = obfd->target_defaulted;
109 return nbfd;
112 /* Delete a BFD. */
114 void
115 _bfd_delete_bfd (bfd *abfd)
117 bfd_hash_table_free (&abfd->section_htab);
118 objalloc_free ((struct objalloc *) abfd->memory);
119 free (abfd);
123 SECTION
124 Opening and closing BFDs
129 FUNCTION
130 bfd_openr
132 SYNOPSIS
133 bfd *bfd_openr (const char *filename, const char *target);
135 DESCRIPTION
136 Open the file @var{filename} (using <<fopen>>) with the target
137 @var{target}. Return a pointer to the created BFD.
139 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
140 that function.
142 If <<NULL>> is returned then an error has occured. Possible errors
143 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
144 <<system_call>> error.
147 bfd *
148 bfd_openr (const char *filename, const char *target)
150 bfd *nbfd;
151 const bfd_target *target_vec;
153 nbfd = _bfd_new_bfd ();
154 if (nbfd == NULL)
155 return NULL;
157 target_vec = bfd_find_target (target, nbfd);
158 if (target_vec == NULL)
160 _bfd_delete_bfd (nbfd);
161 return NULL;
164 nbfd->filename = filename;
165 nbfd->direction = read_direction;
167 if (bfd_open_file (nbfd) == NULL)
169 /* File didn't exist, or some such. */
170 bfd_set_error (bfd_error_system_call);
171 _bfd_delete_bfd (nbfd);
172 return NULL;
175 return nbfd;
178 /* Don't try to `optimize' this function:
180 o - We lock using stack space so that interrupting the locking
181 won't cause a storage leak.
182 o - We open the file stream last, since we don't want to have to
183 close it if anything goes wrong. Closing the stream means closing
184 the file descriptor too, even though we didn't open it. */
186 FUNCTION
187 bfd_fdopenr
189 SYNOPSIS
190 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
192 DESCRIPTION
193 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
194 <<fopen>>. It opens a BFD on a file already described by the
195 @var{fd} supplied.
197 When the file is later <<bfd_close>>d, the file descriptor will
198 be closed. If the caller desires that this file descriptor be
199 cached by BFD (opened as needed, closed as needed to free
200 descriptors for other opens), with the supplied @var{fd} used as
201 an initial file descriptor (but subject to closure at any time),
202 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
203 is to assume no caching; the file descriptor will remain open
204 until <<bfd_close>>, and will not be affected by BFD operations
205 on other files.
207 Possible errors are <<bfd_error_no_memory>>,
208 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
211 bfd *
212 bfd_fdopenr (const char *filename, const char *target, int fd)
214 bfd *nbfd;
215 const bfd_target *target_vec;
216 int fdflags;
218 bfd_set_error (bfd_error_system_call);
219 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
220 fdflags = O_RDWR; /* Assume full access. */
221 #else
222 fdflags = fcntl (fd, F_GETFL, NULL);
223 #endif
224 if (fdflags == -1)
225 return NULL;
227 nbfd = _bfd_new_bfd ();
228 if (nbfd == NULL)
229 return NULL;
231 target_vec = bfd_find_target (target, nbfd);
232 if (target_vec == NULL)
234 _bfd_delete_bfd (nbfd);
235 return NULL;
238 #ifndef HAVE_FDOPEN
239 nbfd->iostream = fopen (filename, FOPEN_RB);
240 #else
241 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
242 switch (fdflags & (O_ACCMODE))
244 case O_RDONLY: nbfd->iostream = fdopen (fd, FOPEN_RB); break;
245 case O_WRONLY: nbfd->iostream = fdopen (fd, FOPEN_RUB); break;
246 case O_RDWR: nbfd->iostream = fdopen (fd, FOPEN_RUB); break;
247 default: abort ();
249 #endif
251 if (nbfd->iostream == NULL)
253 _bfd_delete_bfd (nbfd);
254 return NULL;
257 /* OK, put everything where it belongs. */
258 nbfd->filename = filename;
260 /* As a special case we allow a FD open for read/write to
261 be written through, although doing so requires that we end
262 the previous clause with a preposition. */
263 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
264 switch (fdflags & (O_ACCMODE))
266 case O_RDONLY: nbfd->direction = read_direction; break;
267 case O_WRONLY: nbfd->direction = write_direction; break;
268 case O_RDWR: nbfd->direction = both_direction; break;
269 default: abort ();
272 if (! bfd_cache_init (nbfd))
274 _bfd_delete_bfd (nbfd);
275 return NULL;
277 nbfd->opened_once = TRUE;
279 return nbfd;
283 FUNCTION
284 bfd_openstreamr
286 SYNOPSIS
287 bfd *bfd_openstreamr (const char *, const char *, void *);
289 DESCRIPTION
291 Open a BFD for read access on an existing stdio stream. When
292 the BFD is passed to <<bfd_close>>, the stream will be closed.
295 bfd *
296 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
298 FILE *stream = streamarg;
299 bfd *nbfd;
300 const bfd_target *target_vec;
302 nbfd = _bfd_new_bfd ();
303 if (nbfd == NULL)
304 return NULL;
306 target_vec = bfd_find_target (target, nbfd);
307 if (target_vec == NULL)
309 _bfd_delete_bfd (nbfd);
310 return NULL;
313 nbfd->iostream = stream;
314 nbfd->filename = filename;
315 nbfd->direction = read_direction;
317 if (! bfd_cache_init (nbfd))
319 _bfd_delete_bfd (nbfd);
320 return NULL;
323 return nbfd;
326 /* bfd_openw -- open for writing.
327 Returns a pointer to a freshly-allocated BFD on success, or NULL.
329 See comment by bfd_fdopenr before you try to modify this function. */
332 FUNCTION
333 bfd_openw
335 SYNOPSIS
336 bfd *bfd_openw (const char *filename, const char *target);
338 DESCRIPTION
339 Create a BFD, associated with file @var{filename}, using the
340 file format @var{target}, and return a pointer to it.
342 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
343 <<bfd_error_invalid_target>>.
346 bfd *
347 bfd_openw (const char *filename, const char *target)
349 bfd *nbfd;
350 const bfd_target *target_vec;
352 /* nbfd has to point to head of malloc'ed block so that bfd_close may
353 reclaim it correctly. */
354 nbfd = _bfd_new_bfd ();
355 if (nbfd == NULL)
356 return NULL;
358 target_vec = bfd_find_target (target, nbfd);
359 if (target_vec == NULL)
361 _bfd_delete_bfd (nbfd);
362 return NULL;
365 nbfd->filename = filename;
366 nbfd->direction = write_direction;
368 if (bfd_open_file (nbfd) == NULL)
370 /* File not writeable, etc. */
371 bfd_set_error (bfd_error_system_call);
372 _bfd_delete_bfd (nbfd);
373 return NULL;
376 return nbfd;
381 FUNCTION
382 bfd_close
384 SYNOPSIS
385 bfd_boolean bfd_close (bfd *abfd);
387 DESCRIPTION
389 Close a BFD. If the BFD was open for writing, then pending
390 operations are completed and the file written out and closed.
391 If the created file is executable, then <<chmod>> is called
392 to mark it as such.
394 All memory attached to the BFD is released.
396 The file descriptor associated with the BFD is closed (even
397 if it was passed in to BFD by <<bfd_fdopenr>>).
399 RETURNS
400 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
404 bfd_boolean
405 bfd_close (bfd *abfd)
407 bfd_boolean ret;
409 if (bfd_write_p (abfd))
411 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
412 return FALSE;
415 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
416 return FALSE;
418 ret = bfd_cache_close (abfd);
420 /* If the file was open for writing and is now executable,
421 make it so. */
422 if (ret
423 && abfd->direction == write_direction
424 && abfd->flags & EXEC_P)
426 struct stat buf;
428 if (stat (abfd->filename, &buf) == 0)
430 unsigned int mask = umask (0);
432 umask (mask);
433 chmod (abfd->filename,
434 (0777
435 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
439 _bfd_delete_bfd (abfd);
441 return ret;
445 FUNCTION
446 bfd_close_all_done
448 SYNOPSIS
449 bfd_boolean bfd_close_all_done (bfd *);
451 DESCRIPTION
452 Close a BFD. Differs from <<bfd_close>> since it does not
453 complete any pending operations. This routine would be used
454 if the application had just used BFD for swapping and didn't
455 want to use any of the writing code.
457 If the created file is executable, then <<chmod>> is called
458 to mark it as such.
460 All memory attached to the BFD is released.
462 RETURNS
463 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
466 bfd_boolean
467 bfd_close_all_done (bfd *abfd)
469 bfd_boolean ret;
471 ret = bfd_cache_close (abfd);
473 /* If the file was open for writing and is now executable,
474 make it so. */
475 if (ret
476 && abfd->direction == write_direction
477 && abfd->flags & EXEC_P)
479 struct stat buf;
481 if (stat (abfd->filename, &buf) == 0)
483 unsigned int mask = umask (0);
485 umask (mask);
486 chmod (abfd->filename,
487 (0777
488 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
492 _bfd_delete_bfd (abfd);
494 return ret;
498 FUNCTION
499 bfd_create
501 SYNOPSIS
502 bfd *bfd_create (const char *filename, bfd *templ);
504 DESCRIPTION
505 Create a new BFD in the manner of <<bfd_openw>>, but without
506 opening a file. The new BFD takes the target from the target
507 used by @var{template}. The format is always set to <<bfd_object>>.
510 bfd *
511 bfd_create (const char *filename, bfd *templ)
513 bfd *nbfd;
515 nbfd = _bfd_new_bfd ();
516 if (nbfd == NULL)
517 return NULL;
518 nbfd->filename = filename;
519 if (templ)
520 nbfd->xvec = templ->xvec;
521 nbfd->direction = no_direction;
522 bfd_set_format (nbfd, bfd_object);
524 return nbfd;
528 FUNCTION
529 bfd_make_writable
531 SYNOPSIS
532 bfd_boolean bfd_make_writable (bfd *abfd);
534 DESCRIPTION
535 Takes a BFD as created by <<bfd_create>> and converts it
536 into one like as returned by <<bfd_openw>>. It does this
537 by converting the BFD to BFD_IN_MEMORY. It's assumed that
538 you will call <<bfd_make_readable>> on this bfd later.
540 RETURNS
541 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
544 bfd_boolean
545 bfd_make_writable (bfd *abfd)
547 struct bfd_in_memory *bim;
549 if (abfd->direction != no_direction)
551 bfd_set_error (bfd_error_invalid_operation);
552 return FALSE;
555 bim = bfd_malloc (sizeof (struct bfd_in_memory));
556 abfd->iostream = bim;
557 /* bfd_bwrite will grow these as needed. */
558 bim->size = 0;
559 bim->buffer = 0;
561 abfd->flags |= BFD_IN_MEMORY;
562 abfd->direction = write_direction;
563 abfd->where = 0;
565 return TRUE;
569 FUNCTION
570 bfd_make_readable
572 SYNOPSIS
573 bfd_boolean bfd_make_readable (bfd *abfd);
575 DESCRIPTION
576 Takes a BFD as created by <<bfd_create>> and
577 <<bfd_make_writable>> and converts it into one like as
578 returned by <<bfd_openr>>. It does this by writing the
579 contents out to the memory buffer, then reversing the
580 direction.
582 RETURNS
583 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
585 bfd_boolean
586 bfd_make_readable (bfd *abfd)
588 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
590 bfd_set_error (bfd_error_invalid_operation);
591 return FALSE;
594 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
595 return FALSE;
597 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
598 return FALSE;
601 abfd->arch_info = &bfd_default_arch_struct;
603 abfd->where = 0;
604 abfd->format = bfd_unknown;
605 abfd->my_archive = NULL;
606 abfd->origin = 0;
607 abfd->opened_once = FALSE;
608 abfd->output_has_begun = FALSE;
609 abfd->section_count = 0;
610 abfd->usrdata = NULL;
611 abfd->cacheable = FALSE;
612 abfd->flags = BFD_IN_MEMORY;
613 abfd->mtime_set = FALSE;
615 abfd->target_defaulted = TRUE;
616 abfd->direction = read_direction;
617 abfd->sections = 0;
618 abfd->symcount = 0;
619 abfd->outsymbols = 0;
620 abfd->tdata.any = 0;
622 bfd_section_list_clear (abfd);
623 bfd_check_format (abfd, bfd_object);
625 return TRUE;
629 INTERNAL_FUNCTION
630 bfd_alloc
632 SYNOPSIS
633 void *bfd_alloc (bfd *abfd, size_t wanted);
635 DESCRIPTION
636 Allocate a block of @var{wanted} bytes of memory attached to
637 <<abfd>> and return a pointer to it.
641 void *
642 bfd_alloc (bfd *abfd, bfd_size_type size)
644 void *ret;
646 if (size != (unsigned long) size)
648 bfd_set_error (bfd_error_no_memory);
649 return NULL;
652 ret = objalloc_alloc (abfd->memory, (unsigned long) size);
653 if (ret == NULL)
654 bfd_set_error (bfd_error_no_memory);
655 return ret;
658 void *
659 bfd_zalloc (bfd *abfd, bfd_size_type size)
661 void *res;
663 res = bfd_alloc (abfd, size);
664 if (res)
665 memset (res, 0, (size_t) size);
666 return res;
669 /* Free a block allocated for a BFD.
670 Note: Also frees all more recently allocated blocks! */
672 void
673 bfd_release (bfd *abfd, void *block)
675 objalloc_free_block ((struct objalloc *) abfd->memory, block);
680 GNU Extension: separate debug-info files
682 The idea here is that a special section called .gnu_debuglink might be
683 embedded in a binary file, which indicates that some *other* file
684 contains the real debugging information. This special section contains a
685 filename and CRC32 checksum, which we read and resolve to another file,
686 if it exists.
688 This facilitates "optional" provision of debugging information, without
689 having to provide two complete copies of every binary object (with and
690 without debug symbols).
693 #define GNU_DEBUGLINK ".gnu_debuglink"
695 FUNCTION
696 bfd_calc_gnu_debuglink_crc32
698 SYNOPSIS
699 unsigned long bfd_calc_gnu_debuglink_crc32
700 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
702 DESCRIPTION
703 Computes a CRC value as used in the .gnu_debuglink section.
704 Advances the previously computed @var{crc} value by computing
705 and adding in the crc32 for @var{len} bytes of @var{buf}.
707 RETURNS
708 Return the updated CRC32 value.
711 unsigned long
712 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
713 const unsigned char *buf,
714 bfd_size_type len)
716 static const unsigned long crc32_table[256] =
718 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
719 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
720 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
721 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
722 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
723 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
724 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
725 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
726 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
727 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
728 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
729 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
730 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
731 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
732 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
733 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
734 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
735 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
736 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
737 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
738 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
739 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
740 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
741 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
742 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
743 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
744 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
745 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
746 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
747 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
748 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
749 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
750 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
751 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
752 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
753 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
754 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
755 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
756 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
757 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
758 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
759 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
760 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
761 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
762 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
763 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
764 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
765 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
766 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
767 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
768 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
769 0x2d02ef8d
771 const unsigned char *end;
773 crc = ~crc & 0xffffffff;
774 for (end = buf + len; buf < end; ++ buf)
775 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
776 return ~crc & 0xffffffff;;
781 INTERNAL_FUNCTION
782 get_debug_link_info
784 SYNOPSIS
785 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
787 DESCRIPTION
788 fetch the filename and CRC32 value for any separate debuginfo
789 associated with @var{abfd}. Return NULL if no such info found,
790 otherwise return filename and update @var{crc32_out}.
793 static char *
794 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
796 asection * sect;
797 bfd_size_type debuglink_size;
798 unsigned long crc32;
799 char * contents;
800 int crc_offset;
801 bfd_boolean ret;
803 BFD_ASSERT (abfd);
804 BFD_ASSERT (crc32_out);
806 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
808 if (sect == NULL)
809 return NULL;
811 debuglink_size = bfd_section_size (abfd, sect);
813 contents = malloc (debuglink_size);
814 if (contents == NULL)
815 return NULL;
817 ret = bfd_get_section_contents (abfd, sect, contents, 0, debuglink_size);
818 if (! ret)
820 free (contents);
821 return NULL;
824 /* Crc value is stored after the filename, aligned up to 4 bytes. */
825 crc_offset = strlen (contents) + 1;
826 crc_offset = (crc_offset + 3) & ~3;
828 crc32 = bfd_get_32 (abfd, contents + crc_offset);
830 *crc32_out = crc32;
831 return contents;
835 INTERNAL_FUNCTION
836 separate_debug_file_exists
838 SYNOPSIS
839 bfd_boolean separate_debug_file_exists
840 (char *name, unsigned long crc32);
842 DESCRIPTION
843 Checks to see if @var{name} is a file and if its contents
844 match @var{crc32}.
847 static bfd_boolean
848 separate_debug_file_exists (const char *name, const unsigned long crc)
850 static char buffer [8 * 1024];
851 unsigned long file_crc = 0;
852 int fd;
853 bfd_size_type count;
855 BFD_ASSERT (name);
857 fd = open (name, O_RDONLY);
858 if (fd < 0)
859 return FALSE;
861 while ((count = read (fd, buffer, sizeof (buffer))) > 0)
862 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
864 close (fd);
866 return crc == file_crc;
871 INTERNAL_FUNCTION
872 find_separate_debug_file
874 SYNOPSIS
875 char *find_separate_debug_file (bfd *abfd);
877 DESCRIPTION
878 Searches @var{abfd} for a reference to separate debugging
879 information, scans various locations in the filesystem, including
880 the file tree rooted at @var{debug_file_directory}, and returns a
881 filename of such debugging information if the file is found and has
882 matching CRC32. Returns NULL if no reference to debugging file
883 exists, or file cannot be found.
886 static char *
887 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
889 char *basename;
890 char *dir;
891 char *debugfile;
892 unsigned long crc32;
893 int i;
895 BFD_ASSERT (abfd);
896 if (debug_file_directory == NULL)
897 debug_file_directory = ".";
899 /* BFD may have been opened from a stream. */
900 if (! abfd->filename)
901 return NULL;
903 basename = get_debug_link_info (abfd, & crc32);
904 if (basename == NULL)
905 return NULL;
907 if (strlen (basename) < 1)
909 free (basename);
910 return NULL;
913 dir = strdup (abfd->filename);
914 if (dir == NULL)
916 free (basename);
917 return NULL;
919 BFD_ASSERT (strlen (dir) != 0);
921 /* Strip off filename part. */
922 for (i = strlen (dir) - 1; i >= 0; i--)
923 if (IS_DIR_SEPARATOR (dir[i]))
924 break;
926 dir[i + 1] = '\0';
927 BFD_ASSERT (dir[i] == '/' || dir[0] == '\0')
929 debugfile = malloc (strlen (debug_file_directory) + 1
930 + strlen (dir)
931 + strlen (".debug/")
932 + strlen (basename)
933 + 1);
934 if (debugfile == NULL)
936 free (basename);
937 free (dir);
938 return NULL;
941 /* First try in the same directory as the original file: */
942 strcpy (debugfile, dir);
943 strcat (debugfile, basename);
945 if (separate_debug_file_exists (debugfile, crc32))
947 free (basename);
948 free (dir);
949 return debugfile;
952 /* Then try in a subdirectory called .debug. */
953 strcpy (debugfile, dir);
954 strcat (debugfile, ".debug/");
955 strcat (debugfile, basename);
957 if (separate_debug_file_exists (debugfile, crc32))
959 free (basename);
960 free (dir);
961 return debugfile;
964 /* Then try in the global debugfile directory. */
965 strcpy (debugfile, debug_file_directory);
966 i = strlen (debug_file_directory) - 1;
967 if (i > 0
968 && debug_file_directory[i] != '/'
969 && dir[0] != '/')
970 strcat (debugfile, "/");
971 strcat (debugfile, dir);
972 strcat (debugfile, basename);
974 if (separate_debug_file_exists (debugfile, crc32))
976 free (basename);
977 free (dir);
978 return debugfile;
981 free (debugfile);
982 free (basename);
983 free (dir);
984 return NULL;
989 FUNCTION
990 bfd_follow_gnu_debuglink
992 SYNOPSIS
993 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
995 DESCRIPTION
997 Takes a BFD and searches it for a .gnu_debuglink section. If this
998 section is found, it examines the section for the name and checksum
999 of a '.debug' file containing auxiliary debugging information. It
1000 then searches the filesystem for this .debug file in some standard
1001 locations, including the directory tree rooted at @var{dir}, and if
1002 found returns the full filename.
1004 If @var{dir} is NULL, it will search a default path configured into
1005 libbfd at build time. [XXX this feature is not currently
1006 implemented].
1008 RETURNS
1009 <<NULL>> on any errors or failure to locate the .debug file,
1010 otherwise a pointer to a heap-allocated string containing the
1011 filename. The caller is responsible for freeing this string.
1014 char *
1015 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1017 #if 0 /* Disabled until DEBUGDIR can be defined by configure.in. */
1018 if (dir == NULL)
1019 dir = DEBUGDIR;
1020 #endif
1021 return find_separate_debug_file (abfd, dir);
1025 FUNCTION
1026 bfd_create_gnu_debuglink_section
1028 SYNOPSIS
1029 struct bfd_section *bfd_create_gnu_debuglink_section
1030 (bfd *abfd, const char *filename);
1032 DESCRIPTION
1034 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized
1035 to be big enough to contain a link to the specified @var{filename}.
1037 RETURNS
1038 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is
1039 returned and bfd_error is set.
1042 asection *
1043 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1045 asection *sect;
1046 bfd_size_type debuglink_size;
1048 if (abfd == NULL || filename == NULL)
1050 bfd_set_error (bfd_error_invalid_operation);
1051 return NULL;
1054 /* Strip off any path components in filename. */
1055 filename = lbasename (filename);
1057 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1058 if (sect)
1060 /* Section already exists. */
1061 bfd_set_error (bfd_error_invalid_operation);
1062 return NULL;
1065 sect = bfd_make_section (abfd, GNU_DEBUGLINK);
1066 if (sect == NULL)
1067 return NULL;
1069 if (! bfd_set_section_flags (abfd, sect,
1070 SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING))
1071 /* XXX Should we delete the section from the bfd ? */
1072 return NULL;
1075 debuglink_size = strlen (filename) + 1;
1076 debuglink_size += 3;
1077 debuglink_size &= ~3;
1078 debuglink_size += 4;
1080 if (! bfd_set_section_size (abfd, sect, debuglink_size))
1081 /* XXX Should we delete the section from the bfd ? */
1082 return NULL;
1084 return sect;
1089 FUNCTION
1090 bfd_fill_in_gnu_debuglink_section
1092 SYNOPSIS
1093 bfd_boolean bfd_fill_in_gnu_debuglink_section
1094 (bfd *abfd, struct bfd_section *sect, const char *filename);
1096 DESCRIPTION
1098 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1099 and fills in the contents of the section to contain a link to the
1100 specified @var{filename}. The filename should be relative to the
1101 current directory.
1103 RETURNS
1104 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1105 and bfd_error is set.
1108 bfd_boolean
1109 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1110 struct bfd_section *sect,
1111 const char *filename)
1113 bfd_size_type debuglink_size;
1114 unsigned long crc32;
1115 char * contents;
1116 bfd_size_type crc_offset;
1117 FILE * handle;
1118 static char buffer[8 * 1024];
1119 size_t count;
1121 if (abfd == NULL || sect == NULL || filename == NULL)
1123 bfd_set_error (bfd_error_invalid_operation);
1124 return FALSE;
1127 /* Make sure that we can read the file.
1128 XXX - Should we attempt to locate the debug info file using the same
1129 algorithm as gdb ? At the moment, since we are creating the
1130 .gnu_debuglink section, we insist upon the user providing us with a
1131 correct-for-section-creation-time path, but this need not conform to
1132 the gdb location algorithm. */
1133 handle = fopen (filename, FOPEN_RB);
1134 if (handle == NULL)
1136 bfd_set_error (bfd_error_system_call);
1137 return FALSE;
1140 crc32 = 0;
1141 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1142 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1143 fclose (handle);
1145 /* Strip off any path components in filename,
1146 now that we no longer need them. */
1147 filename = lbasename (filename);
1149 debuglink_size = strlen (filename) + 1;
1150 debuglink_size += 3;
1151 debuglink_size &= ~3;
1152 debuglink_size += 4;
1154 contents = malloc (debuglink_size);
1155 if (contents == NULL)
1157 /* XXX Should we delete the section from the bfd ? */
1158 bfd_set_error (bfd_error_no_memory);
1159 return FALSE;
1162 strcpy (contents, filename);
1163 crc_offset = debuglink_size - 4;
1165 bfd_put_32 (abfd, crc32, contents + crc_offset);
1167 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1169 /* XXX Should we delete the section from the bfd ? */
1170 free (contents);
1171 return FALSE;
1174 return TRUE;