daily update
[binutils.git] / bfd / opncls.c
blob96f1e14ccdadcbf3aeadc2cdddbc73f1d1c9296d
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,
74 bfd_section_hash_newfunc,
75 251))
77 free (nbfd);
78 return NULL;
80 nbfd->sections = NULL;
81 nbfd->section_tail = &nbfd->sections;
82 nbfd->format = bfd_unknown;
83 nbfd->my_archive = NULL;
84 nbfd->origin = 0;
85 nbfd->opened_once = FALSE;
86 nbfd->output_has_begun = FALSE;
87 nbfd->section_count = 0;
88 nbfd->usrdata = NULL;
89 nbfd->cacheable = FALSE;
90 nbfd->flags = BFD_NO_FLAGS;
91 nbfd->mtime_set = FALSE;
93 return nbfd;
96 /* Allocate a new BFD as a member of archive OBFD. */
98 bfd *
99 _bfd_new_bfd_contained_in (bfd *obfd)
101 bfd *nbfd;
103 nbfd = _bfd_new_bfd ();
104 if (nbfd == NULL)
105 return NULL;
106 nbfd->xvec = obfd->xvec;
107 nbfd->my_archive = obfd;
108 nbfd->direction = read_direction;
109 nbfd->target_defaulted = obfd->target_defaulted;
110 return nbfd;
113 /* Delete a BFD. */
115 void
116 _bfd_delete_bfd (bfd *abfd)
118 bfd_hash_table_free (&abfd->section_htab);
119 objalloc_free ((struct objalloc *) abfd->memory);
120 free (abfd);
124 SECTION
125 Opening and closing BFDs
130 FUNCTION
131 bfd_openr
133 SYNOPSIS
134 bfd *bfd_openr (const char *filename, const char *target);
136 DESCRIPTION
137 Open the file @var{filename} (using <<fopen>>) with the target
138 @var{target}. Return a pointer to the created BFD.
140 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
141 that function.
143 If <<NULL>> is returned then an error has occured. Possible errors
144 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
145 <<system_call>> error.
148 bfd *
149 bfd_openr (const char *filename, const char *target)
151 bfd *nbfd;
152 const bfd_target *target_vec;
154 nbfd = _bfd_new_bfd ();
155 if (nbfd == NULL)
156 return NULL;
158 target_vec = bfd_find_target (target, nbfd);
159 if (target_vec == NULL)
161 _bfd_delete_bfd (nbfd);
162 return NULL;
165 nbfd->filename = filename;
166 nbfd->direction = read_direction;
168 if (bfd_open_file (nbfd) == NULL)
170 /* File didn't exist, or some such. */
171 bfd_set_error (bfd_error_system_call);
172 _bfd_delete_bfd (nbfd);
173 return NULL;
176 return nbfd;
179 /* Don't try to `optimize' this function:
181 o - We lock using stack space so that interrupting the locking
182 won't cause a storage leak.
183 o - We open the file stream last, since we don't want to have to
184 close it if anything goes wrong. Closing the stream means closing
185 the file descriptor too, even though we didn't open it. */
187 FUNCTION
188 bfd_fdopenr
190 SYNOPSIS
191 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
193 DESCRIPTION
194 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
195 <<fopen>>. It opens a BFD on a file already described by the
196 @var{fd} supplied.
198 When the file is later <<bfd_close>>d, the file descriptor will
199 be closed. If the caller desires that this file descriptor be
200 cached by BFD (opened as needed, closed as needed to free
201 descriptors for other opens), with the supplied @var{fd} used as
202 an initial file descriptor (but subject to closure at any time),
203 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
204 is to assume no caching; the file descriptor will remain open
205 until <<bfd_close>>, and will not be affected by BFD operations
206 on other files.
208 Possible errors are <<bfd_error_no_memory>>,
209 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
212 bfd *
213 bfd_fdopenr (const char *filename, const char *target, int fd)
215 bfd *nbfd;
216 const bfd_target *target_vec;
217 int fdflags;
219 bfd_set_error (bfd_error_system_call);
220 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
221 fdflags = O_RDWR; /* Assume full access. */
222 #else
223 fdflags = fcntl (fd, F_GETFL, NULL);
224 #endif
225 if (fdflags == -1)
226 return NULL;
228 nbfd = _bfd_new_bfd ();
229 if (nbfd == NULL)
230 return NULL;
232 target_vec = bfd_find_target (target, nbfd);
233 if (target_vec == NULL)
235 _bfd_delete_bfd (nbfd);
236 return NULL;
239 #ifndef HAVE_FDOPEN
240 nbfd->iostream = fopen (filename, FOPEN_RB);
241 #else
242 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
243 switch (fdflags & (O_ACCMODE))
245 case O_RDONLY: nbfd->iostream = fdopen (fd, FOPEN_RB); break;
246 case O_WRONLY: nbfd->iostream = fdopen (fd, FOPEN_RUB); break;
247 case O_RDWR: nbfd->iostream = fdopen (fd, FOPEN_RUB); break;
248 default: abort ();
250 #endif
252 if (nbfd->iostream == NULL)
254 _bfd_delete_bfd (nbfd);
255 return NULL;
258 /* OK, put everything where it belongs. */
259 nbfd->filename = filename;
261 /* As a special case we allow a FD open for read/write to
262 be written through, although doing so requires that we end
263 the previous clause with a preposition. */
264 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
265 switch (fdflags & (O_ACCMODE))
267 case O_RDONLY: nbfd->direction = read_direction; break;
268 case O_WRONLY: nbfd->direction = write_direction; break;
269 case O_RDWR: nbfd->direction = both_direction; break;
270 default: abort ();
273 if (! bfd_cache_init (nbfd))
275 _bfd_delete_bfd (nbfd);
276 return NULL;
278 nbfd->opened_once = TRUE;
280 return nbfd;
284 FUNCTION
285 bfd_openstreamr
287 SYNOPSIS
288 bfd *bfd_openstreamr (const char *, const char *, void *);
290 DESCRIPTION
292 Open a BFD for read access on an existing stdio stream. When
293 the BFD is passed to <<bfd_close>>, the stream will be closed.
296 bfd *
297 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
299 FILE *stream = streamarg;
300 bfd *nbfd;
301 const bfd_target *target_vec;
303 nbfd = _bfd_new_bfd ();
304 if (nbfd == NULL)
305 return NULL;
307 target_vec = bfd_find_target (target, nbfd);
308 if (target_vec == NULL)
310 _bfd_delete_bfd (nbfd);
311 return NULL;
314 nbfd->iostream = stream;
315 nbfd->filename = filename;
316 nbfd->direction = read_direction;
318 if (! bfd_cache_init (nbfd))
320 _bfd_delete_bfd (nbfd);
321 return NULL;
324 return nbfd;
327 /* bfd_openw -- open for writing.
328 Returns a pointer to a freshly-allocated BFD on success, or NULL.
330 See comment by bfd_fdopenr before you try to modify this function. */
333 FUNCTION
334 bfd_openw
336 SYNOPSIS
337 bfd *bfd_openw (const char *filename, const char *target);
339 DESCRIPTION
340 Create a BFD, associated with file @var{filename}, using the
341 file format @var{target}, and return a pointer to it.
343 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
344 <<bfd_error_invalid_target>>.
347 bfd *
348 bfd_openw (const char *filename, const char *target)
350 bfd *nbfd;
351 const bfd_target *target_vec;
353 /* nbfd has to point to head of malloc'ed block so that bfd_close may
354 reclaim it correctly. */
355 nbfd = _bfd_new_bfd ();
356 if (nbfd == NULL)
357 return NULL;
359 target_vec = bfd_find_target (target, nbfd);
360 if (target_vec == NULL)
362 _bfd_delete_bfd (nbfd);
363 return NULL;
366 nbfd->filename = filename;
367 nbfd->direction = write_direction;
369 if (bfd_open_file (nbfd) == NULL)
371 /* File not writeable, etc. */
372 bfd_set_error (bfd_error_system_call);
373 _bfd_delete_bfd (nbfd);
374 return NULL;
377 return nbfd;
382 FUNCTION
383 bfd_close
385 SYNOPSIS
386 bfd_boolean bfd_close (bfd *abfd);
388 DESCRIPTION
390 Close a BFD. If the BFD was open for writing, then pending
391 operations are completed and the file written out and closed.
392 If the created file is executable, then <<chmod>> is called
393 to mark it as such.
395 All memory attached to the BFD is released.
397 The file descriptor associated with the BFD is closed (even
398 if it was passed in to BFD by <<bfd_fdopenr>>).
400 RETURNS
401 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
405 bfd_boolean
406 bfd_close (bfd *abfd)
408 bfd_boolean ret;
410 if (bfd_write_p (abfd))
412 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
413 return FALSE;
416 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
417 return FALSE;
419 ret = bfd_cache_close (abfd);
421 /* If the file was open for writing and is now executable,
422 make it so. */
423 if (ret
424 && abfd->direction == write_direction
425 && abfd->flags & EXEC_P)
427 struct stat buf;
429 if (stat (abfd->filename, &buf) == 0)
431 unsigned int mask = umask (0);
433 umask (mask);
434 chmod (abfd->filename,
435 (0777
436 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
440 _bfd_delete_bfd (abfd);
442 return ret;
446 FUNCTION
447 bfd_close_all_done
449 SYNOPSIS
450 bfd_boolean bfd_close_all_done (bfd *);
452 DESCRIPTION
453 Close a BFD. Differs from <<bfd_close>> since it does not
454 complete any pending operations. This routine would be used
455 if the application had just used BFD for swapping and didn't
456 want to use any of the writing code.
458 If the created file is executable, then <<chmod>> is called
459 to mark it as such.
461 All memory attached to the BFD is released.
463 RETURNS
464 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
467 bfd_boolean
468 bfd_close_all_done (bfd *abfd)
470 bfd_boolean ret;
472 ret = bfd_cache_close (abfd);
474 /* If the file was open for writing and is now executable,
475 make it so. */
476 if (ret
477 && abfd->direction == write_direction
478 && abfd->flags & EXEC_P)
480 struct stat buf;
482 if (stat (abfd->filename, &buf) == 0)
484 unsigned int mask = umask (0);
486 umask (mask);
487 chmod (abfd->filename,
488 (0777
489 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
493 _bfd_delete_bfd (abfd);
495 return ret;
499 FUNCTION
500 bfd_create
502 SYNOPSIS
503 bfd *bfd_create (const char *filename, bfd *templ);
505 DESCRIPTION
506 Create a new BFD in the manner of <<bfd_openw>>, but without
507 opening a file. The new BFD takes the target from the target
508 used by @var{template}. The format is always set to <<bfd_object>>.
511 bfd *
512 bfd_create (const char *filename, bfd *templ)
514 bfd *nbfd;
516 nbfd = _bfd_new_bfd ();
517 if (nbfd == NULL)
518 return NULL;
519 nbfd->filename = filename;
520 if (templ)
521 nbfd->xvec = templ->xvec;
522 nbfd->direction = no_direction;
523 bfd_set_format (nbfd, bfd_object);
525 return nbfd;
529 FUNCTION
530 bfd_make_writable
532 SYNOPSIS
533 bfd_boolean bfd_make_writable (bfd *abfd);
535 DESCRIPTION
536 Takes a BFD as created by <<bfd_create>> and converts it
537 into one like as returned by <<bfd_openw>>. It does this
538 by converting the BFD to BFD_IN_MEMORY. It's assumed that
539 you will call <<bfd_make_readable>> on this bfd later.
541 RETURNS
542 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
545 bfd_boolean
546 bfd_make_writable (bfd *abfd)
548 struct bfd_in_memory *bim;
550 if (abfd->direction != no_direction)
552 bfd_set_error (bfd_error_invalid_operation);
553 return FALSE;
556 bim = bfd_malloc (sizeof (struct bfd_in_memory));
557 abfd->iostream = bim;
558 /* bfd_bwrite will grow these as needed. */
559 bim->size = 0;
560 bim->buffer = 0;
562 abfd->flags |= BFD_IN_MEMORY;
563 abfd->direction = write_direction;
564 abfd->where = 0;
566 return TRUE;
570 FUNCTION
571 bfd_make_readable
573 SYNOPSIS
574 bfd_boolean bfd_make_readable (bfd *abfd);
576 DESCRIPTION
577 Takes a BFD as created by <<bfd_create>> and
578 <<bfd_make_writable>> and converts it into one like as
579 returned by <<bfd_openr>>. It does this by writing the
580 contents out to the memory buffer, then reversing the
581 direction.
583 RETURNS
584 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
586 bfd_boolean
587 bfd_make_readable (bfd *abfd)
589 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
591 bfd_set_error (bfd_error_invalid_operation);
592 return FALSE;
595 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
596 return FALSE;
598 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
599 return FALSE;
602 abfd->arch_info = &bfd_default_arch_struct;
604 abfd->where = 0;
605 abfd->format = bfd_unknown;
606 abfd->my_archive = NULL;
607 abfd->origin = 0;
608 abfd->opened_once = FALSE;
609 abfd->output_has_begun = FALSE;
610 abfd->section_count = 0;
611 abfd->usrdata = NULL;
612 abfd->cacheable = FALSE;
613 abfd->flags = BFD_IN_MEMORY;
614 abfd->mtime_set = FALSE;
616 abfd->target_defaulted = TRUE;
617 abfd->direction = read_direction;
618 abfd->sections = 0;
619 abfd->symcount = 0;
620 abfd->outsymbols = 0;
621 abfd->tdata.any = 0;
623 bfd_section_list_clear (abfd);
624 bfd_check_format (abfd, bfd_object);
626 return TRUE;
630 INTERNAL_FUNCTION
631 bfd_alloc
633 SYNOPSIS
634 void *bfd_alloc (bfd *abfd, size_t wanted);
636 DESCRIPTION
637 Allocate a block of @var{wanted} bytes of memory attached to
638 <<abfd>> and return a pointer to it.
642 void *
643 bfd_alloc (bfd *abfd, bfd_size_type size)
645 void *ret;
647 if (size != (unsigned long) size)
649 bfd_set_error (bfd_error_no_memory);
650 return NULL;
653 ret = objalloc_alloc (abfd->memory, (unsigned long) size);
654 if (ret == NULL)
655 bfd_set_error (bfd_error_no_memory);
656 return ret;
659 void *
660 bfd_zalloc (bfd *abfd, bfd_size_type size)
662 void *res;
664 res = bfd_alloc (abfd, size);
665 if (res)
666 memset (res, 0, (size_t) size);
667 return res;
670 /* Free a block allocated for a BFD.
671 Note: Also frees all more recently allocated blocks! */
673 void
674 bfd_release (bfd *abfd, void *block)
676 objalloc_free_block ((struct objalloc *) abfd->memory, block);
681 GNU Extension: separate debug-info files
683 The idea here is that a special section called .gnu_debuglink might be
684 embedded in a binary file, which indicates that some *other* file
685 contains the real debugging information. This special section contains a
686 filename and CRC32 checksum, which we read and resolve to another file,
687 if it exists.
689 This facilitates "optional" provision of debugging information, without
690 having to provide two complete copies of every binary object (with and
691 without debug symbols).
694 #define GNU_DEBUGLINK ".gnu_debuglink"
696 FUNCTION
697 bfd_calc_gnu_debuglink_crc32
699 SYNOPSIS
700 unsigned long bfd_calc_gnu_debuglink_crc32
701 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
703 DESCRIPTION
704 Computes a CRC value as used in the .gnu_debuglink section.
705 Advances the previously computed @var{crc} value by computing
706 and adding in the crc32 for @var{len} bytes of @var{buf}.
708 RETURNS
709 Return the updated CRC32 value.
712 unsigned long
713 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
714 const unsigned char *buf,
715 bfd_size_type len)
717 static const unsigned long crc32_table[256] =
719 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
720 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
721 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
722 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
723 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
724 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
725 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
726 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
727 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
728 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
729 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
730 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
731 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
732 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
733 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
734 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
735 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
736 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
737 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
738 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
739 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
740 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
741 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
742 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
743 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
744 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
745 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
746 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
747 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
748 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
749 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
750 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
751 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
752 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
753 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
754 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
755 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
756 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
757 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
758 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
759 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
760 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
761 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
762 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
763 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
764 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
765 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
766 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
767 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
768 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
769 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
770 0x2d02ef8d
772 const unsigned char *end;
774 crc = ~crc & 0xffffffff;
775 for (end = buf + len; buf < end; ++ buf)
776 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
777 return ~crc & 0xffffffff;;
782 INTERNAL_FUNCTION
783 get_debug_link_info
785 SYNOPSIS
786 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
788 DESCRIPTION
789 fetch the filename and CRC32 value for any separate debuginfo
790 associated with @var{abfd}. Return NULL if no such info found,
791 otherwise return filename and update @var{crc32_out}.
794 static char *
795 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
797 asection * sect;
798 bfd_size_type debuglink_size;
799 unsigned long crc32;
800 char * contents;
801 int crc_offset;
802 bfd_boolean ret;
804 BFD_ASSERT (abfd);
805 BFD_ASSERT (crc32_out);
807 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
809 if (sect == NULL)
810 return NULL;
812 debuglink_size = bfd_section_size (abfd, sect);
814 contents = malloc (debuglink_size);
815 if (contents == NULL)
816 return NULL;
818 ret = bfd_get_section_contents (abfd, sect, contents, 0, debuglink_size);
819 if (! ret)
821 free (contents);
822 return NULL;
825 /* Crc value is stored after the filename, aligned up to 4 bytes. */
826 crc_offset = strlen (contents) + 1;
827 crc_offset = (crc_offset + 3) & ~3;
829 crc32 = bfd_get_32 (abfd, contents + crc_offset);
831 *crc32_out = crc32;
832 return contents;
836 INTERNAL_FUNCTION
837 separate_debug_file_exists
839 SYNOPSIS
840 bfd_boolean separate_debug_file_exists
841 (char *name, unsigned long crc32);
843 DESCRIPTION
844 Checks to see if @var{name} is a file and if its contents
845 match @var{crc32}.
848 static bfd_boolean
849 separate_debug_file_exists (const char *name, const unsigned long crc)
851 static char buffer [8 * 1024];
852 unsigned long file_crc = 0;
853 int fd;
854 bfd_size_type count;
856 BFD_ASSERT (name);
858 fd = open (name, O_RDONLY);
859 if (fd < 0)
860 return FALSE;
862 while ((count = read (fd, buffer, sizeof (buffer))) > 0)
863 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
865 close (fd);
867 return crc == file_crc;
872 INTERNAL_FUNCTION
873 find_separate_debug_file
875 SYNOPSIS
876 char *find_separate_debug_file (bfd *abfd);
878 DESCRIPTION
879 Searches @var{abfd} for a reference to separate debugging
880 information, scans various locations in the filesystem, including
881 the file tree rooted at @var{debug_file_directory}, and returns a
882 filename of such debugging information if the file is found and has
883 matching CRC32. Returns NULL if no reference to debugging file
884 exists, or file cannot be found.
887 static char *
888 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
890 char *basename;
891 char *dir;
892 char *debugfile;
893 unsigned long crc32;
894 int i;
896 BFD_ASSERT (abfd);
897 if (debug_file_directory == NULL)
898 debug_file_directory = ".";
900 /* BFD may have been opened from a stream. */
901 if (! abfd->filename)
902 return NULL;
904 basename = get_debug_link_info (abfd, & crc32);
905 if (basename == NULL)
906 return NULL;
908 if (strlen (basename) < 1)
910 free (basename);
911 return NULL;
914 dir = strdup (abfd->filename);
915 if (dir == NULL)
917 free (basename);
918 return NULL;
920 BFD_ASSERT (strlen (dir) != 0);
922 /* Strip off filename part. */
923 for (i = strlen (dir) - 1; i >= 0; i--)
924 if (IS_DIR_SEPARATOR (dir[i]))
925 break;
927 dir[i + 1] = '\0';
928 BFD_ASSERT (dir[i] == '/' || dir[0] == '\0')
930 debugfile = malloc (strlen (debug_file_directory) + 1
931 + strlen (dir)
932 + strlen (".debug/")
933 + strlen (basename)
934 + 1);
935 if (debugfile == NULL)
937 free (basename);
938 free (dir);
939 return NULL;
942 /* First try in the same directory as the original file: */
943 strcpy (debugfile, dir);
944 strcat (debugfile, basename);
946 if (separate_debug_file_exists (debugfile, crc32))
948 free (basename);
949 free (dir);
950 return debugfile;
953 /* Then try in a subdirectory called .debug. */
954 strcpy (debugfile, dir);
955 strcat (debugfile, ".debug/");
956 strcat (debugfile, basename);
958 if (separate_debug_file_exists (debugfile, crc32))
960 free (basename);
961 free (dir);
962 return debugfile;
965 /* Then try in the global debugfile directory. */
966 strcpy (debugfile, debug_file_directory);
967 i = strlen (debug_file_directory) - 1;
968 if (i > 0
969 && debug_file_directory[i] != '/'
970 && dir[0] != '/')
971 strcat (debugfile, "/");
972 strcat (debugfile, dir);
973 strcat (debugfile, basename);
975 if (separate_debug_file_exists (debugfile, crc32))
977 free (basename);
978 free (dir);
979 return debugfile;
982 free (debugfile);
983 free (basename);
984 free (dir);
985 return NULL;
990 FUNCTION
991 bfd_follow_gnu_debuglink
993 SYNOPSIS
994 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
996 DESCRIPTION
998 Takes a BFD and searches it for a .gnu_debuglink section. If this
999 section is found, examines the section for the name and checksum of
1000 a '.debug' file containing auxiliary debugging
1001 information. Searches filesystem for .debug file in some standard
1002 locations, including the directory tree rooted at @var{dir}, and if
1003 found returns the full filename. If @var{dir} is NULL, will search
1004 default path configured into libbfd at build time.
1006 RETURNS
1007 <<NULL>> on any errors or failure to locate the .debug file,
1008 otherwise a pointer to a heap-allocated string containing the
1009 filename. The caller is responsible for freeing this string.
1012 char *
1013 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1015 #if 0 /* Disabled until DEBUGDIR can be defined by configure.in */
1016 if (dir == NULL)
1017 dir = DEBUGDIR;
1018 #endif
1019 return find_separate_debug_file (abfd, dir);
1023 FUNCTION
1024 bfd_create_gnu_debuglink_section
1026 SYNOPSIS
1027 struct bfd_section *bfd_create_gnu_debuglink_section
1028 (bfd *abfd, const char *filename);
1030 DESCRIPTION
1032 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized
1033 to be big enough to contain a link to the specified @var{filename}.
1035 RETURNS
1036 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is
1037 returned and bfd_error is set.
1040 asection *
1041 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1043 asection *sect;
1044 bfd_size_type debuglink_size;
1046 if (abfd == NULL || filename == NULL)
1048 bfd_set_error (bfd_error_invalid_operation);
1049 return NULL;
1052 /* Strip off any path components in filename. */
1053 filename = lbasename (filename);
1055 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1056 if (sect)
1058 /* Section already exists. */
1059 bfd_set_error (bfd_error_invalid_operation);
1060 return NULL;
1063 sect = bfd_make_section (abfd, GNU_DEBUGLINK);
1064 if (sect == NULL)
1065 return NULL;
1067 if (! bfd_set_section_flags (abfd, sect,
1068 SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING))
1069 /* XXX Should we delete the section from the bfd ? */
1070 return NULL;
1073 debuglink_size = strlen (filename) + 1;
1074 debuglink_size += 3;
1075 debuglink_size &= ~3;
1076 debuglink_size += 4;
1078 if (! bfd_set_section_size (abfd, sect, debuglink_size))
1079 /* XXX Should we delete the section from the bfd ? */
1080 return NULL;
1082 return sect;
1087 FUNCTION
1088 bfd_fill_in_gnu_debuglink_section
1090 SYNOPSIS
1091 bfd_boolean bfd_fill_in_gnu_debuglink_section
1092 (bfd *abfd, struct bfd_section *sect, const char *filename);
1094 DESCRIPTION
1096 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1097 and fills in the contents of the section to contain a link to the
1098 specified @var{filename}. The filename should be relative to the
1099 current directory.
1101 RETURNS
1102 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1103 and bfd_error is set.
1106 bfd_boolean
1107 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1108 struct bfd_section *sect,
1109 const char *filename)
1111 bfd_size_type debuglink_size;
1112 unsigned long crc32;
1113 char * contents;
1114 bfd_size_type crc_offset;
1115 FILE * handle;
1116 static char buffer[8 * 1024];
1117 size_t count;
1119 if (abfd == NULL || sect == NULL || filename == NULL)
1121 bfd_set_error (bfd_error_invalid_operation);
1122 return FALSE;
1125 /* Make sure that we can read the file.
1126 XXX - Should we attempt to locate the debug info file using the same
1127 algorithm as gdb ? At the moment, since we are creating the
1128 .gnu_debuglink section, we insist upon the user providing us with a
1129 correct-for-section-creation-time path, but this need not conform to
1130 the gdb location algorithm. */
1131 handle = fopen (filename, FOPEN_RB);
1132 if (handle == NULL)
1134 bfd_set_error (bfd_error_system_call);
1135 return FALSE;
1138 crc32 = 0;
1139 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1140 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1141 fclose (handle);
1143 /* Strip off any path components in filename,
1144 now that we no longer need them. */
1145 filename = lbasename (filename);
1147 debuglink_size = strlen (filename) + 1;
1148 debuglink_size += 3;
1149 debuglink_size &= ~3;
1150 debuglink_size += 4;
1152 contents = malloc (debuglink_size);
1153 if (contents == NULL)
1155 /* XXX Should we delete the section from the bfd ? */
1156 bfd_set_error (bfd_error_no_memory);
1157 return FALSE;
1160 strcpy (contents, filename);
1161 crc_offset = debuglink_size - 4;
1163 bfd_put_32 (abfd, crc32, contents + crc_offset);
1165 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1167 /* XXX Should we delete the section from the bfd ? */
1168 free (contents);
1169 return FALSE;
1172 return TRUE;