daily update
[binutils.git] / bfd / opncls.c
blobb02b137889a1226df67357512cc056de39d451d0
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, 2006
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. */
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 sizeof (struct section_hash_entry), 251))
76 free (nbfd);
77 return NULL;
79 nbfd->sections = NULL;
80 nbfd->section_last = NULL;
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->iovec = obfd->iovec;
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
127 SUBSECTION
128 Functions for opening and closing
132 FUNCTION
133 bfd_fopen
135 SYNOPSIS
136 bfd *bfd_fopen (const char *filename, const char *target,
137 const char *mode, int fd);
139 DESCRIPTION
140 Open the file @var{filename} with the target @var{target}.
141 Return a pointer to the created BFD. If @var{fd} is not -1,
142 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
143 is used. @var{mode} is passed directly to <<fopen>> or
144 <<fdopen>>.
146 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
147 that function.
149 The new BFD is marked as cacheable iff @var{fd} is -1.
151 If <<NULL>> is returned then an error has occured. Possible errors
152 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
153 <<system_call>> error.
156 bfd *
157 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
159 bfd *nbfd;
160 const bfd_target *target_vec;
162 nbfd = _bfd_new_bfd ();
163 if (nbfd == NULL)
164 return NULL;
166 target_vec = bfd_find_target (target, nbfd);
167 if (target_vec == NULL)
169 _bfd_delete_bfd (nbfd);
170 return NULL;
173 #ifdef HAVE_FDOPEN
174 if (fd != -1)
175 nbfd->iostream = fdopen (fd, mode);
176 else
177 #endif
178 nbfd->iostream = real_fopen (filename, mode);
179 if (nbfd->iostream == NULL)
181 bfd_set_error (bfd_error_system_call);
182 _bfd_delete_bfd (nbfd);
183 return NULL;
186 /* OK, put everything where it belongs. */
187 nbfd->filename = filename;
189 /* Figure out whether the user is opening the file for reading,
190 writing, or both, by looking at the MODE argument. */
191 if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
192 && mode[1] == '+')
193 nbfd->direction = both_direction;
194 else if (mode[0] == 'r')
195 nbfd->direction = read_direction;
196 else
197 nbfd->direction = write_direction;
199 if (! bfd_cache_init (nbfd))
201 _bfd_delete_bfd (nbfd);
202 return NULL;
204 nbfd->opened_once = TRUE;
205 /* If we opened the file by name, mark it cacheable; we can close it
206 and reopen it later. However, if a file descriptor was provided,
207 then it may have been opened with special flags that make it
208 unsafe to close and reopen the file. */
209 if (fd == -1)
210 bfd_set_cacheable (nbfd, TRUE);
212 return nbfd;
216 FUNCTION
217 bfd_openr
219 SYNOPSIS
220 bfd *bfd_openr (const char *filename, const char *target);
222 DESCRIPTION
223 Open the file @var{filename} (using <<fopen>>) with the target
224 @var{target}. Return a pointer to the created BFD.
226 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
227 that function.
229 If <<NULL>> is returned then an error has occured. Possible errors
230 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
231 <<system_call>> error.
234 bfd *
235 bfd_openr (const char *filename, const char *target)
237 return bfd_fopen (filename, target, FOPEN_RB, -1);
240 /* Don't try to `optimize' this function:
242 o - We lock using stack space so that interrupting the locking
243 won't cause a storage leak.
244 o - We open the file stream last, since we don't want to have to
245 close it if anything goes wrong. Closing the stream means closing
246 the file descriptor too, even though we didn't open it. */
248 FUNCTION
249 bfd_fdopenr
251 SYNOPSIS
252 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
254 DESCRIPTION
255 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
256 <<fopen>>. It opens a BFD on a file already described by the
257 @var{fd} supplied.
259 When the file is later <<bfd_close>>d, the file descriptor will
260 be closed. If the caller desires that this file descriptor be
261 cached by BFD (opened as needed, closed as needed to free
262 descriptors for other opens), with the supplied @var{fd} used as
263 an initial file descriptor (but subject to closure at any time),
264 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
265 is to assume no caching; the file descriptor will remain open
266 until <<bfd_close>>, and will not be affected by BFD operations
267 on other files.
269 Possible errors are <<bfd_error_no_memory>>,
270 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
273 bfd *
274 bfd_fdopenr (const char *filename, const char *target, int fd)
276 const char *mode;
277 #if defined(HAVE_FCNTL) && defined(F_GETFL)
278 int fdflags;
279 #endif
281 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
282 mode = FOPEN_RUB; /* Assume full access. */
283 #else
284 fdflags = fcntl (fd, F_GETFL, NULL);
285 if (fdflags == -1)
287 bfd_set_error (bfd_error_system_call);
288 return NULL;
291 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
292 switch (fdflags & (O_ACCMODE))
294 case O_RDONLY: mode = FOPEN_RB; break;
295 case O_WRONLY: mode = FOPEN_RUB; break;
296 case O_RDWR: mode = FOPEN_RUB; break;
297 default: abort ();
299 #endif
301 return bfd_fopen (filename, target, mode, fd);
305 FUNCTION
306 bfd_openstreamr
308 SYNOPSIS
309 bfd *bfd_openstreamr (const char *, const char *, void *);
311 DESCRIPTION
313 Open a BFD for read access on an existing stdio stream. When
314 the BFD is passed to <<bfd_close>>, the stream will be closed.
317 bfd *
318 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
320 FILE *stream = streamarg;
321 bfd *nbfd;
322 const bfd_target *target_vec;
324 nbfd = _bfd_new_bfd ();
325 if (nbfd == NULL)
326 return NULL;
328 target_vec = bfd_find_target (target, nbfd);
329 if (target_vec == NULL)
331 _bfd_delete_bfd (nbfd);
332 return NULL;
335 nbfd->iostream = stream;
336 nbfd->filename = filename;
337 nbfd->direction = read_direction;
339 if (! bfd_cache_init (nbfd))
341 _bfd_delete_bfd (nbfd);
342 return NULL;
345 return nbfd;
349 FUNCTION
350 bfd_openr_iovec
352 SYNOPSIS
353 bfd *bfd_openr_iovec (const char *filename, const char *target,
354 void *(*open) (struct bfd *nbfd,
355 void *open_closure),
356 void *open_closure,
357 file_ptr (*pread) (struct bfd *nbfd,
358 void *stream,
359 void *buf,
360 file_ptr nbytes,
361 file_ptr offset),
362 int (*close) (struct bfd *nbfd,
363 void *stream));
365 DESCRIPTION
367 Create and return a BFD backed by a read-only @var{stream}.
368 The @var{stream} is created using @var{open}, accessed using
369 @var{pread} and destroyed using @var{close}.
371 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
372 that function.
374 Calls @var{open} (which can call <<bfd_zalloc>> and
375 <<bfd_get_filename>>) to obtain the read-only stream backing
376 the BFD. @var{open} either succeeds returning the
377 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
378 (setting <<bfd_error>>).
380 Calls @var{pread} to request @var{nbytes} of data from
381 @var{stream} starting at @var{offset} (e.g., via a call to
382 <<bfd_read>>). @var{pread} either succeeds returning the
383 number of bytes read (which can be less than @var{nbytes} when
384 end-of-file), or fails returning -1 (setting <<bfd_error>>).
386 Calls @var{close} when the BFD is later closed using
387 <<bfd_close>>. @var{close} either succeeds returning 0, or
388 fails returning -1 (setting <<bfd_error>>).
390 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
391 occurred. Possible errors are <<bfd_error_no_memory>>,
392 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
396 struct opncls
398 void *stream;
399 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
400 file_ptr nbytes, file_ptr offset);
401 int (*close) (struct bfd *abfd, void *stream);
402 file_ptr where;
405 static file_ptr
406 opncls_btell (struct bfd *abfd)
408 struct opncls *vec = abfd->iostream;
409 return vec->where;
412 static int
413 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
415 struct opncls *vec = abfd->iostream;
416 switch (whence)
418 case SEEK_SET: vec->where = offset; break;
419 case SEEK_CUR: vec->where += offset; break;
420 case SEEK_END: return -1;
422 return 0;
425 static file_ptr
426 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
428 struct opncls *vec = abfd->iostream;
429 file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
430 if (nread < 0)
431 return nread;
432 vec->where += nread;
433 return nread;
436 static file_ptr
437 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
438 const void *where ATTRIBUTE_UNUSED,
439 file_ptr nbytes ATTRIBUTE_UNUSED)
441 return -1;
444 static int
445 opncls_bclose (struct bfd *abfd)
447 struct opncls *vec = abfd->iostream;
448 /* Since the VEC's memory is bound to the bfd deleting the bfd will
449 free it. */
450 int status = 0;
451 if (vec->close != NULL)
452 status = (vec->close) (abfd, vec->stream);
453 abfd->iostream = NULL;
454 return status;
457 static int
458 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
460 return 0;
463 static int
464 opncls_bstat (struct bfd *abfd ATTRIBUTE_UNUSED, struct stat *sb)
466 memset (sb, 0, sizeof (*sb));
467 return 0;
470 static const struct bfd_iovec opncls_iovec = {
471 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
472 &opncls_bclose, &opncls_bflush, &opncls_bstat
475 bfd *
476 bfd_openr_iovec (const char *filename, const char *target,
477 void *(*open) (struct bfd *nbfd,
478 void *open_closure),
479 void *open_closure,
480 file_ptr (*pread) (struct bfd *abfd,
481 void *stream,
482 void *buf,
483 file_ptr nbytes,
484 file_ptr offset),
485 int (*close) (struct bfd *nbfd,
486 void *stream))
488 bfd *nbfd;
489 const bfd_target *target_vec;
490 struct opncls *vec;
491 void *stream;
493 nbfd = _bfd_new_bfd ();
494 if (nbfd == NULL)
495 return NULL;
497 target_vec = bfd_find_target (target, nbfd);
498 if (target_vec == NULL)
500 _bfd_delete_bfd (nbfd);
501 return NULL;
504 nbfd->filename = filename;
505 nbfd->direction = read_direction;
507 stream = open (nbfd, open_closure);
508 if (stream == NULL)
510 _bfd_delete_bfd (nbfd);
511 return NULL;
514 vec = bfd_zalloc (nbfd, sizeof (struct opncls));
515 vec->stream = stream;
516 vec->pread = pread;
517 vec->close = close;
519 nbfd->iovec = &opncls_iovec;
520 nbfd->iostream = vec;
522 return nbfd;
525 /* bfd_openw -- open for writing.
526 Returns a pointer to a freshly-allocated BFD on success, or NULL.
528 See comment by bfd_fdopenr before you try to modify this function. */
531 FUNCTION
532 bfd_openw
534 SYNOPSIS
535 bfd *bfd_openw (const char *filename, const char *target);
537 DESCRIPTION
538 Create a BFD, associated with file @var{filename}, using the
539 file format @var{target}, and return a pointer to it.
541 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
542 <<bfd_error_invalid_target>>.
545 bfd *
546 bfd_openw (const char *filename, const char *target)
548 bfd *nbfd;
549 const bfd_target *target_vec;
551 /* nbfd has to point to head of malloc'ed block so that bfd_close may
552 reclaim it correctly. */
553 nbfd = _bfd_new_bfd ();
554 if (nbfd == NULL)
555 return NULL;
557 target_vec = bfd_find_target (target, nbfd);
558 if (target_vec == NULL)
560 _bfd_delete_bfd (nbfd);
561 return NULL;
564 nbfd->filename = filename;
565 nbfd->direction = write_direction;
567 if (bfd_open_file (nbfd) == NULL)
569 /* File not writeable, etc. */
570 bfd_set_error (bfd_error_system_call);
571 _bfd_delete_bfd (nbfd);
572 return NULL;
575 return nbfd;
580 FUNCTION
581 bfd_close
583 SYNOPSIS
584 bfd_boolean bfd_close (bfd *abfd);
586 DESCRIPTION
588 Close a BFD. If the BFD was open for writing, then pending
589 operations are completed and the file written out and closed.
590 If the created file is executable, then <<chmod>> is called
591 to mark it as such.
593 All memory attached to the BFD is released.
595 The file descriptor associated with the BFD is closed (even
596 if it was passed in to BFD by <<bfd_fdopenr>>).
598 RETURNS
599 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
603 bfd_boolean
604 bfd_close (bfd *abfd)
606 bfd_boolean ret;
608 if (bfd_write_p (abfd))
610 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
611 return FALSE;
614 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
615 return FALSE;
617 /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
618 vector. */
619 if (!(abfd->flags & BFD_IN_MEMORY))
620 ret = abfd->iovec->bclose (abfd);
621 else
622 ret = TRUE;
624 /* If the file was open for writing and is now executable,
625 make it so. */
626 if (ret
627 && abfd->direction == write_direction
628 && abfd->flags & EXEC_P)
630 struct stat buf;
632 if (stat (abfd->filename, &buf) == 0)
634 unsigned int mask = umask (0);
636 umask (mask);
637 chmod (abfd->filename,
638 (0777
639 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
643 _bfd_delete_bfd (abfd);
645 return ret;
649 FUNCTION
650 bfd_close_all_done
652 SYNOPSIS
653 bfd_boolean bfd_close_all_done (bfd *);
655 DESCRIPTION
656 Close a BFD. Differs from <<bfd_close>> since it does not
657 complete any pending operations. This routine would be used
658 if the application had just used BFD for swapping and didn't
659 want to use any of the writing code.
661 If the created file is executable, then <<chmod>> is called
662 to mark it as such.
664 All memory attached to the BFD is released.
666 RETURNS
667 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
670 bfd_boolean
671 bfd_close_all_done (bfd *abfd)
673 bfd_boolean ret;
675 ret = bfd_cache_close (abfd);
677 /* If the file was open for writing and is now executable,
678 make it so. */
679 if (ret
680 && abfd->direction == write_direction
681 && abfd->flags & EXEC_P)
683 struct stat buf;
685 if (stat (abfd->filename, &buf) == 0)
687 unsigned int mask = umask (0);
689 umask (mask);
690 chmod (abfd->filename,
691 (0777
692 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
696 _bfd_delete_bfd (abfd);
698 return ret;
702 FUNCTION
703 bfd_create
705 SYNOPSIS
706 bfd *bfd_create (const char *filename, bfd *templ);
708 DESCRIPTION
709 Create a new BFD in the manner of <<bfd_openw>>, but without
710 opening a file. The new BFD takes the target from the target
711 used by @var{template}. The format is always set to <<bfd_object>>.
714 bfd *
715 bfd_create (const char *filename, bfd *templ)
717 bfd *nbfd;
719 nbfd = _bfd_new_bfd ();
720 if (nbfd == NULL)
721 return NULL;
722 nbfd->filename = filename;
723 if (templ)
724 nbfd->xvec = templ->xvec;
725 nbfd->direction = no_direction;
726 bfd_set_format (nbfd, bfd_object);
728 return nbfd;
732 FUNCTION
733 bfd_make_writable
735 SYNOPSIS
736 bfd_boolean bfd_make_writable (bfd *abfd);
738 DESCRIPTION
739 Takes a BFD as created by <<bfd_create>> and converts it
740 into one like as returned by <<bfd_openw>>. It does this
741 by converting the BFD to BFD_IN_MEMORY. It's assumed that
742 you will call <<bfd_make_readable>> on this bfd later.
744 RETURNS
745 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
748 bfd_boolean
749 bfd_make_writable (bfd *abfd)
751 struct bfd_in_memory *bim;
753 if (abfd->direction != no_direction)
755 bfd_set_error (bfd_error_invalid_operation);
756 return FALSE;
759 bim = bfd_malloc (sizeof (struct bfd_in_memory));
760 abfd->iostream = bim;
761 /* bfd_bwrite will grow these as needed. */
762 bim->size = 0;
763 bim->buffer = 0;
765 abfd->flags |= BFD_IN_MEMORY;
766 abfd->direction = write_direction;
767 abfd->where = 0;
769 return TRUE;
773 FUNCTION
774 bfd_make_readable
776 SYNOPSIS
777 bfd_boolean bfd_make_readable (bfd *abfd);
779 DESCRIPTION
780 Takes a BFD as created by <<bfd_create>> and
781 <<bfd_make_writable>> and converts it into one like as
782 returned by <<bfd_openr>>. It does this by writing the
783 contents out to the memory buffer, then reversing the
784 direction.
786 RETURNS
787 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
789 bfd_boolean
790 bfd_make_readable (bfd *abfd)
792 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
794 bfd_set_error (bfd_error_invalid_operation);
795 return FALSE;
798 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
799 return FALSE;
801 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
802 return FALSE;
805 abfd->arch_info = &bfd_default_arch_struct;
807 abfd->where = 0;
808 abfd->format = bfd_unknown;
809 abfd->my_archive = NULL;
810 abfd->origin = 0;
811 abfd->opened_once = FALSE;
812 abfd->output_has_begun = FALSE;
813 abfd->section_count = 0;
814 abfd->usrdata = NULL;
815 abfd->cacheable = FALSE;
816 abfd->flags = BFD_IN_MEMORY;
817 abfd->mtime_set = FALSE;
819 abfd->target_defaulted = TRUE;
820 abfd->direction = read_direction;
821 abfd->sections = 0;
822 abfd->symcount = 0;
823 abfd->outsymbols = 0;
824 abfd->tdata.any = 0;
826 bfd_section_list_clear (abfd);
827 bfd_check_format (abfd, bfd_object);
829 return TRUE;
833 INTERNAL_FUNCTION
834 bfd_alloc
836 SYNOPSIS
837 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
839 DESCRIPTION
840 Allocate a block of @var{wanted} bytes of memory attached to
841 <<abfd>> and return a pointer to it.
844 void *
845 bfd_alloc (bfd *abfd, bfd_size_type size)
847 void *ret;
849 if (size != (unsigned long) size)
851 bfd_set_error (bfd_error_no_memory);
852 return NULL;
855 ret = objalloc_alloc (abfd->memory, (unsigned long) size);
856 if (ret == NULL)
857 bfd_set_error (bfd_error_no_memory);
858 return ret;
862 INTERNAL_FUNCTION
863 bfd_alloc2
865 SYNOPSIS
866 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
868 DESCRIPTION
869 Allocate a block of @var{nmemb} elements of @var{size} bytes each
870 of memory attached to <<abfd>> and return a pointer to it.
873 void *
874 bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
876 void *ret;
878 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
879 && size != 0
880 && nmemb > ~(bfd_size_type) 0 / size)
882 bfd_set_error (bfd_error_no_memory);
883 return NULL;
886 size *= nmemb;
888 if (size != (unsigned long) size)
890 bfd_set_error (bfd_error_no_memory);
891 return NULL;
894 ret = objalloc_alloc (abfd->memory, (unsigned long) size);
895 if (ret == NULL)
896 bfd_set_error (bfd_error_no_memory);
897 return ret;
901 INTERNAL_FUNCTION
902 bfd_zalloc
904 SYNOPSIS
905 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
907 DESCRIPTION
908 Allocate a block of @var{wanted} bytes of zeroed memory
909 attached to <<abfd>> and return a pointer to it.
912 void *
913 bfd_zalloc (bfd *abfd, bfd_size_type size)
915 void *res;
917 res = bfd_alloc (abfd, size);
918 if (res)
919 memset (res, 0, (size_t) size);
920 return res;
924 INTERNAL_FUNCTION
925 bfd_zalloc2
927 SYNOPSIS
928 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
930 DESCRIPTION
931 Allocate a block of @var{nmemb} elements of @var{size} bytes each
932 of zeroed memory attached to <<abfd>> and return a pointer to it.
935 void *
936 bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
938 void *res;
940 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
941 && size != 0
942 && nmemb > ~(bfd_size_type) 0 / size)
944 bfd_set_error (bfd_error_no_memory);
945 return NULL;
948 size *= nmemb;
950 res = bfd_alloc (abfd, size);
951 if (res)
952 memset (res, 0, (size_t) size);
953 return res;
956 /* Free a block allocated for a BFD.
957 Note: Also frees all more recently allocated blocks! */
959 void
960 bfd_release (bfd *abfd, void *block)
962 objalloc_free_block ((struct objalloc *) abfd->memory, block);
967 GNU Extension: separate debug-info files
969 The idea here is that a special section called .gnu_debuglink might be
970 embedded in a binary file, which indicates that some *other* file
971 contains the real debugging information. This special section contains a
972 filename and CRC32 checksum, which we read and resolve to another file,
973 if it exists.
975 This facilitates "optional" provision of debugging information, without
976 having to provide two complete copies of every binary object (with and
977 without debug symbols).
980 #define GNU_DEBUGLINK ".gnu_debuglink"
982 FUNCTION
983 bfd_calc_gnu_debuglink_crc32
985 SYNOPSIS
986 unsigned long bfd_calc_gnu_debuglink_crc32
987 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
989 DESCRIPTION
990 Computes a CRC value as used in the .gnu_debuglink section.
991 Advances the previously computed @var{crc} value by computing
992 and adding in the crc32 for @var{len} bytes of @var{buf}.
994 RETURNS
995 Return the updated CRC32 value.
998 unsigned long
999 bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1000 const unsigned char *buf,
1001 bfd_size_type len)
1003 static const unsigned long crc32_table[256] =
1005 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1006 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1007 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1008 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1009 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1010 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1011 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1012 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1013 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1014 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1015 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1016 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1017 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1018 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1019 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1020 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1021 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1022 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1023 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1024 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1025 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1026 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1027 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1028 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1029 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1030 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1031 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1032 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1033 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1034 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1035 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1036 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1037 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1038 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1039 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1040 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1041 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1042 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1043 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1044 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1045 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1046 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1047 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1048 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1049 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1050 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1051 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1052 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1053 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1054 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1055 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1056 0x2d02ef8d
1058 const unsigned char *end;
1060 crc = ~crc & 0xffffffff;
1061 for (end = buf + len; buf < end; ++ buf)
1062 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1063 return ~crc & 0xffffffff;;
1068 INTERNAL_FUNCTION
1069 get_debug_link_info
1071 SYNOPSIS
1072 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1074 DESCRIPTION
1075 fetch the filename and CRC32 value for any separate debuginfo
1076 associated with @var{abfd}. Return NULL if no such info found,
1077 otherwise return filename and update @var{crc32_out}.
1080 static char *
1081 get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1083 asection *sect;
1084 unsigned long crc32;
1085 bfd_byte *contents;
1086 int crc_offset;
1087 char *name;
1089 BFD_ASSERT (abfd);
1090 BFD_ASSERT (crc32_out);
1092 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1094 if (sect == NULL)
1095 return NULL;
1097 if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1099 if (contents != NULL)
1100 free (contents);
1101 return NULL;
1104 /* Crc value is stored after the filename, aligned up to 4 bytes. */
1105 name = (char *) contents;
1106 crc_offset = strlen (name) + 1;
1107 crc_offset = (crc_offset + 3) & ~3;
1109 crc32 = bfd_get_32 (abfd, contents + crc_offset);
1111 *crc32_out = crc32;
1112 return name;
1116 INTERNAL_FUNCTION
1117 separate_debug_file_exists
1119 SYNOPSIS
1120 bfd_boolean separate_debug_file_exists
1121 (char *name, unsigned long crc32);
1123 DESCRIPTION
1124 Checks to see if @var{name} is a file and if its contents
1125 match @var{crc32}.
1128 static bfd_boolean
1129 separate_debug_file_exists (const char *name, const unsigned long crc)
1131 static unsigned char buffer [8 * 1024];
1132 unsigned long file_crc = 0;
1133 int fd;
1134 bfd_size_type count;
1136 BFD_ASSERT (name);
1138 fd = open (name, O_RDONLY);
1139 if (fd < 0)
1140 return FALSE;
1142 while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1143 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1145 close (fd);
1147 return crc == file_crc;
1152 INTERNAL_FUNCTION
1153 find_separate_debug_file
1155 SYNOPSIS
1156 char *find_separate_debug_file (bfd *abfd);
1158 DESCRIPTION
1159 Searches @var{abfd} for a reference to separate debugging
1160 information, scans various locations in the filesystem, including
1161 the file tree rooted at @var{debug_file_directory}, and returns a
1162 filename of such debugging information if the file is found and has
1163 matching CRC32. Returns NULL if no reference to debugging file
1164 exists, or file cannot be found.
1167 static char *
1168 find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1170 char *basename;
1171 char *dir;
1172 char *debugfile;
1173 unsigned long crc32;
1174 int i;
1176 BFD_ASSERT (abfd);
1177 if (debug_file_directory == NULL)
1178 debug_file_directory = ".";
1180 /* BFD may have been opened from a stream. */
1181 if (! abfd->filename)
1182 return NULL;
1184 basename = get_debug_link_info (abfd, & crc32);
1185 if (basename == NULL)
1186 return NULL;
1188 if (strlen (basename) < 1)
1190 free (basename);
1191 return NULL;
1194 dir = strdup (abfd->filename);
1195 if (dir == NULL)
1197 free (basename);
1198 return NULL;
1200 BFD_ASSERT (strlen (dir) != 0);
1202 /* Strip off filename part. */
1203 for (i = strlen (dir) - 1; i >= 0; i--)
1204 if (IS_DIR_SEPARATOR (dir[i]))
1205 break;
1207 dir[i + 1] = '\0';
1208 BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
1210 debugfile = malloc (strlen (debug_file_directory) + 1
1211 + strlen (dir)
1212 + strlen (".debug/")
1213 + strlen (basename)
1214 + 1);
1215 if (debugfile == NULL)
1217 free (basename);
1218 free (dir);
1219 return NULL;
1222 /* First try in the same directory as the original file: */
1223 strcpy (debugfile, dir);
1224 strcat (debugfile, basename);
1226 if (separate_debug_file_exists (debugfile, crc32))
1228 free (basename);
1229 free (dir);
1230 return debugfile;
1233 /* Then try in a subdirectory called .debug. */
1234 strcpy (debugfile, dir);
1235 strcat (debugfile, ".debug/");
1236 strcat (debugfile, basename);
1238 if (separate_debug_file_exists (debugfile, crc32))
1240 free (basename);
1241 free (dir);
1242 return debugfile;
1245 /* Then try in the global debugfile directory. */
1246 strcpy (debugfile, debug_file_directory);
1247 i = strlen (debug_file_directory) - 1;
1248 if (i > 0
1249 && debug_file_directory[i] != '/'
1250 && dir[0] != '/')
1251 strcat (debugfile, "/");
1252 strcat (debugfile, dir);
1253 strcat (debugfile, basename);
1255 if (separate_debug_file_exists (debugfile, crc32))
1257 free (basename);
1258 free (dir);
1259 return debugfile;
1262 free (debugfile);
1263 free (basename);
1264 free (dir);
1265 return NULL;
1270 FUNCTION
1271 bfd_follow_gnu_debuglink
1273 SYNOPSIS
1274 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1276 DESCRIPTION
1278 Takes a BFD and searches it for a .gnu_debuglink section. If this
1279 section is found, it examines the section for the name and checksum
1280 of a '.debug' file containing auxiliary debugging information. It
1281 then searches the filesystem for this .debug file in some standard
1282 locations, including the directory tree rooted at @var{dir}, and if
1283 found returns the full filename.
1285 If @var{dir} is NULL, it will search a default path configured into
1286 libbfd at build time. [XXX this feature is not currently
1287 implemented].
1289 RETURNS
1290 <<NULL>> on any errors or failure to locate the .debug file,
1291 otherwise a pointer to a heap-allocated string containing the
1292 filename. The caller is responsible for freeing this string.
1295 char *
1296 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1298 return find_separate_debug_file (abfd, dir);
1302 FUNCTION
1303 bfd_create_gnu_debuglink_section
1305 SYNOPSIS
1306 struct bfd_section *bfd_create_gnu_debuglink_section
1307 (bfd *abfd, const char *filename);
1309 DESCRIPTION
1311 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The section is sized
1312 to be big enough to contain a link to the specified @var{filename}.
1314 RETURNS
1315 A pointer to the new section is returned if all is ok. Otherwise <<NULL>> is
1316 returned and bfd_error is set.
1319 asection *
1320 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1322 asection *sect;
1323 bfd_size_type debuglink_size;
1325 if (abfd == NULL || filename == NULL)
1327 bfd_set_error (bfd_error_invalid_operation);
1328 return NULL;
1331 /* Strip off any path components in filename. */
1332 filename = lbasename (filename);
1334 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1335 if (sect)
1337 /* Section already exists. */
1338 bfd_set_error (bfd_error_invalid_operation);
1339 return NULL;
1342 sect = bfd_make_section (abfd, GNU_DEBUGLINK);
1343 if (sect == NULL)
1344 return NULL;
1346 if (! bfd_set_section_flags (abfd, sect,
1347 SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING))
1348 /* XXX Should we delete the section from the bfd ? */
1349 return NULL;
1352 debuglink_size = strlen (filename) + 1;
1353 debuglink_size += 3;
1354 debuglink_size &= ~3;
1355 debuglink_size += 4;
1357 if (! bfd_set_section_size (abfd, sect, debuglink_size))
1358 /* XXX Should we delete the section from the bfd ? */
1359 return NULL;
1361 return sect;
1366 FUNCTION
1367 bfd_fill_in_gnu_debuglink_section
1369 SYNOPSIS
1370 bfd_boolean bfd_fill_in_gnu_debuglink_section
1371 (bfd *abfd, struct bfd_section *sect, const char *filename);
1373 DESCRIPTION
1375 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1376 and fills in the contents of the section to contain a link to the
1377 specified @var{filename}. The filename should be relative to the
1378 current directory.
1380 RETURNS
1381 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1382 and bfd_error is set.
1385 bfd_boolean
1386 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1387 struct bfd_section *sect,
1388 const char *filename)
1390 bfd_size_type debuglink_size;
1391 unsigned long crc32;
1392 char * contents;
1393 bfd_size_type crc_offset;
1394 FILE * handle;
1395 static unsigned char buffer[8 * 1024];
1396 size_t count;
1398 if (abfd == NULL || sect == NULL || filename == NULL)
1400 bfd_set_error (bfd_error_invalid_operation);
1401 return FALSE;
1404 /* Make sure that we can read the file.
1405 XXX - Should we attempt to locate the debug info file using the same
1406 algorithm as gdb ? At the moment, since we are creating the
1407 .gnu_debuglink section, we insist upon the user providing us with a
1408 correct-for-section-creation-time path, but this need not conform to
1409 the gdb location algorithm. */
1410 handle = real_fopen (filename, FOPEN_RB);
1411 if (handle == NULL)
1413 bfd_set_error (bfd_error_system_call);
1414 return FALSE;
1417 crc32 = 0;
1418 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1419 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1420 fclose (handle);
1422 /* Strip off any path components in filename,
1423 now that we no longer need them. */
1424 filename = lbasename (filename);
1426 debuglink_size = strlen (filename) + 1;
1427 debuglink_size += 3;
1428 debuglink_size &= ~3;
1429 debuglink_size += 4;
1431 contents = malloc (debuglink_size);
1432 if (contents == NULL)
1434 /* XXX Should we delete the section from the bfd ? */
1435 bfd_set_error (bfd_error_no_memory);
1436 return FALSE;
1439 strcpy (contents, filename);
1440 crc_offset = debuglink_size - 4;
1442 bfd_put_32 (abfd, crc32, contents + crc_offset);
1444 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1446 /* XXX Should we delete the section from the bfd ? */
1447 free (contents);
1448 return FALSE;
1451 return TRUE;