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.
5
6   Written by Cygnus Support.
7
8   This file is part of BFD, the Binary File Descriptor library.
9
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.
14
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.
19
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.  */
23
24#include "bfd.h"
25#include "sysdep.h"
26#include "objalloc.h"
27#include "libbfd.h"
28#include "libiberty.h"
29
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
39
40/* Counter used to initialize the bfd identifier.  */
41
42static unsigned int _bfd_id_counter = 0;
43
44/* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
45   if we do that we can't use fcntl.  */
46
47/* Return a new BFD.  All BFD's are allocated through this routine.  */
48
49bfd *
50_bfd_new_bfd (void)
51{
52  bfd *nbfd;
53
54  nbfd = bfd_zmalloc (sizeof (bfd));
55  if (nbfd == NULL)
56    return NULL;
57
58  nbfd->id = _bfd_id_counter++;
59
60  nbfd->memory = objalloc_create ();
61  if (nbfd->memory == NULL)
62    {
63      bfd_set_error (bfd_error_no_memory);
64      free (nbfd);
65      return NULL;
66    }
67
68  nbfd->arch_info = &bfd_default_arch_struct;
69
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))
75    {
76      free (nbfd);
77      return NULL;
78    }
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;
91
92  return nbfd;
93}
94
95/* Allocate a new BFD as a member of archive OBFD.  */
96
97bfd *
98_bfd_new_bfd_contained_in (bfd *obfd)
99{
100  bfd *nbfd;
101
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;
111}
112
113/* Delete a BFD.  */
114
115void
116_bfd_delete_bfd (bfd *abfd)
117{
118  bfd_hash_table_free (&abfd->section_htab);
119  objalloc_free ((struct objalloc *) abfd->memory);
120  free (abfd);
121}
122
123/*
124SECTION
125	Opening and closing BFDs
126
127SUBSECTION
128	Functions for opening and closing
129*/
130
131/*
132FUNCTION
133	bfd_fopen
134
135SYNOPSIS
136	bfd *bfd_fopen (const char *filename, const char *target,
137                        const char *mode, int fd);
138
139DESCRIPTION
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>>.
145
146	Calls <<bfd_find_target>>, so @var{target} is interpreted as by
147	that function.
148
149	The new BFD is marked as cacheable iff @var{fd} is -1.
150
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.
154*/
155
156bfd *
157bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
158{
159  bfd *nbfd;
160  const bfd_target *target_vec;
161
162  nbfd = _bfd_new_bfd ();
163  if (nbfd == NULL)
164    return NULL;
165
166  target_vec = bfd_find_target (target, nbfd);
167  if (target_vec == NULL)
168    {
169      _bfd_delete_bfd (nbfd);
170      return NULL;
171    }
172
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)
180    {
181      bfd_set_error (bfd_error_system_call);
182      _bfd_delete_bfd (nbfd);
183      return NULL;
184    }
185
186  /* OK, put everything where it belongs.  */
187  nbfd->filename = filename;
188
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;
198
199  if (! bfd_cache_init (nbfd))
200    {
201      _bfd_delete_bfd (nbfd);
202      return NULL;
203    }
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);
211
212  return nbfd;
213}
214
215/*
216FUNCTION
217	bfd_openr
218
219SYNOPSIS
220	bfd *bfd_openr (const char *filename, const char *target);
221
222DESCRIPTION
223	Open the file @var{filename} (using <<fopen>>) with the target
224	@var{target}.  Return a pointer to the created BFD.
225
226	Calls <<bfd_find_target>>, so @var{target} is interpreted as by
227	that function.
228
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.
232*/
233
234bfd *
235bfd_openr (const char *filename, const char *target)
236{
237  return bfd_fopen (filename, target, FOPEN_RB, -1);
238}
239
240/* Don't try to `optimize' this function:
241
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.  */
247/*
248FUNCTION
249	bfd_fdopenr
250
251SYNOPSIS
252	bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
253
254DESCRIPTION
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.
258
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.
268
269	Possible errors are <<bfd_error_no_memory>>,
270	<<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
271*/
272
273bfd *
274bfd_fdopenr (const char *filename, const char *target, int fd)
275{
276  const char *mode;
277#if defined(HAVE_FCNTL) && defined(F_GETFL)
278  int fdflags;
279#endif
280
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)
286    {
287      bfd_set_error (bfd_error_system_call);
288      return NULL;
289    }
290
291  /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
292  switch (fdflags & (O_ACCMODE))
293    {
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 ();
298    }
299#endif
300
301  return bfd_fopen (filename, target, mode, fd);
302}
303
304/*
305FUNCTION
306	bfd_openstreamr
307
308SYNOPSIS
309	bfd *bfd_openstreamr (const char *, const char *, void *);
310
311DESCRIPTION
312
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.
315*/
316
317bfd *
318bfd_openstreamr (const char *filename, const char *target, void *streamarg)
319{
320  FILE *stream = streamarg;
321  bfd *nbfd;
322  const bfd_target *target_vec;
323
324  nbfd = _bfd_new_bfd ();
325  if (nbfd == NULL)
326    return NULL;
327
328  target_vec = bfd_find_target (target, nbfd);
329  if (target_vec == NULL)
330    {
331      _bfd_delete_bfd (nbfd);
332      return NULL;
333    }
334
335  nbfd->iostream = stream;
336  nbfd->filename = filename;
337  nbfd->direction = read_direction;
338
339  if (! bfd_cache_init (nbfd))
340    {
341      _bfd_delete_bfd (nbfd);
342      return NULL;
343    }
344
345  return nbfd;
346}
347
348/*
349FUNCTION
350	bfd_openr_iovec
351
352SYNOPSIS
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));
364
365DESCRIPTION
366
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}.
370
371	Calls <<bfd_find_target>>, so @var{target} is interpreted as by
372	that function.
373
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>>).
379
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>>).
385
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>>).
389
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>>.
393
394*/
395
396struct opncls
397{
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;
403};
404
405static file_ptr
406opncls_btell (struct bfd *abfd)
407{
408  struct opncls *vec = abfd->iostream;
409  return vec->where;
410}
411
412static int
413opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
414{
415  struct opncls *vec = abfd->iostream;
416  switch (whence)
417    {
418    case SEEK_SET: vec->where = offset; break;
419    case SEEK_CUR: vec->where += offset; break;
420    case SEEK_END: return -1;
421    }
422  return 0;
423}
424
425static file_ptr
426opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
427{
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;
434}
435
436static file_ptr
437opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
438	      const void *where ATTRIBUTE_UNUSED,
439	      file_ptr nbytes ATTRIBUTE_UNUSED)
440{
441  return -1;
442}
443
444static int
445opncls_bclose (struct bfd *abfd)
446{
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;
455}
456
457static int
458opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
459{
460  return 0;
461}
462
463static int
464opncls_bstat (struct bfd *abfd ATTRIBUTE_UNUSED, struct stat *sb)
465{
466  memset (sb, 0, sizeof (*sb));
467  return 0;
468}
469
470static const struct bfd_iovec opncls_iovec = {
471  &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
472  &opncls_bclose, &opncls_bflush, &opncls_bstat
473};
474
475bfd *
476bfd_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))
487{
488  bfd *nbfd;
489  const bfd_target *target_vec;
490  struct opncls *vec;
491  void *stream;
492
493  nbfd = _bfd_new_bfd ();
494  if (nbfd == NULL)
495    return NULL;
496
497  target_vec = bfd_find_target (target, nbfd);
498  if (target_vec == NULL)
499    {
500      _bfd_delete_bfd (nbfd);
501      return NULL;
502    }
503
504  nbfd->filename = filename;
505  nbfd->direction = read_direction;
506
507  stream = open (nbfd, open_closure);
508  if (stream == NULL)
509    {
510      _bfd_delete_bfd (nbfd);
511      return NULL;
512    }
513
514  vec = bfd_zalloc (nbfd, sizeof (struct opncls));
515  vec->stream = stream;
516  vec->pread = pread;
517  vec->close = close;
518
519  nbfd->iovec = &opncls_iovec;
520  nbfd->iostream = vec;
521
522  return nbfd;
523}
524
525/* bfd_openw -- open for writing.
526   Returns a pointer to a freshly-allocated BFD on success, or NULL.
527
528   See comment by bfd_fdopenr before you try to modify this function.  */
529
530/*
531FUNCTION
532	bfd_openw
533
534SYNOPSIS
535	bfd *bfd_openw (const char *filename, const char *target);
536
537DESCRIPTION
538	Create a BFD, associated with file @var{filename}, using the
539	file format @var{target}, and return a pointer to it.
540
541	Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
542	<<bfd_error_invalid_target>>.
543*/
544
545bfd *
546bfd_openw (const char *filename, const char *target)
547{
548  bfd *nbfd;
549  const bfd_target *target_vec;
550
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;
556
557  target_vec = bfd_find_target (target, nbfd);
558  if (target_vec == NULL)
559    {
560      _bfd_delete_bfd (nbfd);
561      return NULL;
562    }
563
564  nbfd->filename = filename;
565  nbfd->direction = write_direction;
566
567  if (bfd_open_file (nbfd) == NULL)
568    {
569      /* File not writeable, etc.  */
570      bfd_set_error (bfd_error_system_call);
571      _bfd_delete_bfd (nbfd);
572      return NULL;
573  }
574
575  return nbfd;
576}
577
578/*
579
580FUNCTION
581	bfd_close
582
583SYNOPSIS
584	bfd_boolean bfd_close (bfd *abfd);
585
586DESCRIPTION
587
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.
592
593	All memory attached to the BFD is released.
594
595	The file descriptor associated with the BFD is closed (even
596	if it was passed in to BFD by <<bfd_fdopenr>>).
597
598RETURNS
599	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
600*/
601
602
603bfd_boolean
604bfd_close (bfd *abfd)
605{
606  bfd_boolean ret;
607
608  if (bfd_write_p (abfd))
609    {
610      if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
611	return FALSE;
612    }
613
614  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
615    return FALSE;
616
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;
623
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)
629    {
630      struct stat buf;
631
632      if (stat (abfd->filename, &buf) == 0)
633	{
634	  unsigned int mask = umask (0);
635
636	  umask (mask);
637	  chmod (abfd->filename,
638		 (0777
639		  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
640	}
641    }
642
643  _bfd_delete_bfd (abfd);
644
645  return ret;
646}
647
648/*
649FUNCTION
650	bfd_close_all_done
651
652SYNOPSIS
653	bfd_boolean bfd_close_all_done (bfd *);
654
655DESCRIPTION
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.
660
661	If the created file is executable, then <<chmod>> is called
662	to mark it as such.
663
664	All memory attached to the BFD is released.
665
666RETURNS
667	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
668*/
669
670bfd_boolean
671bfd_close_all_done (bfd *abfd)
672{
673  bfd_boolean ret;
674
675  ret = bfd_cache_close (abfd);
676
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)
682    {
683      struct stat buf;
684
685      if (stat (abfd->filename, &buf) == 0)
686	{
687	  unsigned int mask = umask (0);
688
689	  umask (mask);
690	  chmod (abfd->filename,
691		 (0777
692		  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
693	}
694    }
695
696  _bfd_delete_bfd (abfd);
697
698  return ret;
699}
700
701/*
702FUNCTION
703	bfd_create
704
705SYNOPSIS
706	bfd *bfd_create (const char *filename, bfd *templ);
707
708DESCRIPTION
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>>.
712*/
713
714bfd *
715bfd_create (const char *filename, bfd *templ)
716{
717  bfd *nbfd;
718
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);
727
728  return nbfd;
729}
730
731/*
732FUNCTION
733	bfd_make_writable
734
735SYNOPSIS
736	bfd_boolean bfd_make_writable (bfd *abfd);
737
738DESCRIPTION
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.
743
744RETURNS
745	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
746*/
747
748bfd_boolean
749bfd_make_writable (bfd *abfd)
750{
751  struct bfd_in_memory *bim;
752
753  if (abfd->direction != no_direction)
754    {
755      bfd_set_error (bfd_error_invalid_operation);
756      return FALSE;
757    }
758
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;
764
765  abfd->flags |= BFD_IN_MEMORY;
766  abfd->direction = write_direction;
767  abfd->where = 0;
768
769  return TRUE;
770}
771
772/*
773FUNCTION
774	bfd_make_readable
775
776SYNOPSIS
777	bfd_boolean bfd_make_readable (bfd *abfd);
778
779DESCRIPTION
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.
785
786RETURNS
787	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
788
789bfd_boolean
790bfd_make_readable (bfd *abfd)
791{
792  if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
793    {
794      bfd_set_error (bfd_error_invalid_operation);
795      return FALSE;
796    }
797
798  if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
799    return FALSE;
800
801  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
802    return FALSE;
803
804
805  abfd->arch_info = &bfd_default_arch_struct;
806
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;
818
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;
825
826  bfd_section_list_clear (abfd);
827  bfd_check_format (abfd, bfd_object);
828
829  return TRUE;
830}
831
832/*
833INTERNAL_FUNCTION
834	bfd_alloc
835
836SYNOPSIS
837	void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
838
839DESCRIPTION
840	Allocate a block of @var{wanted} bytes of memory attached to
841	<<abfd>> and return a pointer to it.
842*/
843
844void *
845bfd_alloc (bfd *abfd, bfd_size_type size)
846{
847  void *ret;
848
849  if (size != (unsigned long) size)
850    {
851      bfd_set_error (bfd_error_no_memory);
852      return NULL;
853    }
854
855  ret = objalloc_alloc (abfd->memory, (unsigned long) size);
856  if (ret == NULL)
857    bfd_set_error (bfd_error_no_memory);
858  return ret;
859}
860
861/*
862INTERNAL_FUNCTION
863	bfd_alloc2
864
865SYNOPSIS
866	void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
867
868DESCRIPTION
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.
871*/
872
873void *
874bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
875{
876  void *ret;
877
878  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
879      && size != 0
880      && nmemb > ~(bfd_size_type) 0 / size)
881    {
882      bfd_set_error (bfd_error_no_memory);
883      return NULL;
884    }
885
886  size *= nmemb;
887
888  if (size != (unsigned long) size)
889    {
890      bfd_set_error (bfd_error_no_memory);
891      return NULL;
892    }
893
894  ret = objalloc_alloc (abfd->memory, (unsigned long) size);
895  if (ret == NULL)
896    bfd_set_error (bfd_error_no_memory);
897  return ret;
898}
899
900/*
901INTERNAL_FUNCTION
902	bfd_zalloc
903
904SYNOPSIS
905	void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
906
907DESCRIPTION
908	Allocate a block of @var{wanted} bytes of zeroed memory
909	attached to <<abfd>> and return a pointer to it.
910*/
911
912void *
913bfd_zalloc (bfd *abfd, bfd_size_type size)
914{
915  void *res;
916
917  res = bfd_alloc (abfd, size);
918  if (res)
919    memset (res, 0, (size_t) size);
920  return res;
921}
922
923/*
924INTERNAL_FUNCTION
925	bfd_zalloc2
926
927SYNOPSIS
928	void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
929
930DESCRIPTION
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.
933*/
934
935void *
936bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
937{
938  void *res;
939
940  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
941      && size != 0
942      && nmemb > ~(bfd_size_type) 0 / size)
943    {
944      bfd_set_error (bfd_error_no_memory);
945      return NULL;
946    }
947
948  size *= nmemb;
949
950  res = bfd_alloc (abfd, size);
951  if (res)
952    memset (res, 0, (size_t) size);
953  return res;
954}
955
956/* Free a block allocated for a BFD.
957   Note:  Also frees all more recently allocated blocks!  */
958
959void
960bfd_release (bfd *abfd, void *block)
961{
962  objalloc_free_block ((struct objalloc *) abfd->memory, block);
963}
964
965
966/*
967   GNU Extension: separate debug-info files
968
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.
974
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).
978*/
979
980#define GNU_DEBUGLINK	".gnu_debuglink"
981/*
982FUNCTION
983	bfd_calc_gnu_debuglink_crc32
984
985SYNOPSIS
986	unsigned long bfd_calc_gnu_debuglink_crc32
987	  (unsigned long crc, const unsigned char *buf, bfd_size_type len);
988
989DESCRIPTION
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}.
993
994RETURNS
995	Return the updated CRC32 value.
996*/
997
998unsigned long
999bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1000			      const unsigned char *buf,
1001			      bfd_size_type len)
1002{
1003  static const unsigned long crc32_table[256] =
1004    {
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
1057    };
1058  const unsigned char *end;
1059
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;;
1064}
1065
1066
1067/*
1068INTERNAL_FUNCTION
1069	get_debug_link_info
1070
1071SYNOPSIS
1072	char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1073
1074DESCRIPTION
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}.
1078*/
1079
1080static char *
1081get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1082{
1083  asection *sect;
1084  unsigned long crc32;
1085  bfd_byte *contents;
1086  int crc_offset;
1087  char *name;
1088
1089  BFD_ASSERT (abfd);
1090  BFD_ASSERT (crc32_out);
1091
1092  sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1093
1094  if (sect == NULL)
1095    return NULL;
1096
1097  if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1098    {
1099      if (contents != NULL)
1100	free (contents);
1101      return NULL;
1102    }
1103
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;
1108
1109  crc32 = bfd_get_32 (abfd, contents + crc_offset);
1110
1111  *crc32_out = crc32;
1112  return name;
1113}
1114
1115/*
1116INTERNAL_FUNCTION
1117	separate_debug_file_exists
1118
1119SYNOPSIS
1120	bfd_boolean separate_debug_file_exists
1121	  (char *name, unsigned long crc32);
1122
1123DESCRIPTION
1124	Checks to see if @var{name} is a file and if its contents
1125	match @var{crc32}.
1126*/
1127
1128static bfd_boolean
1129separate_debug_file_exists (const char *name, const unsigned long crc)
1130{
1131  static unsigned char buffer [8 * 1024];
1132  unsigned long file_crc = 0;
1133  int fd;
1134  bfd_size_type count;
1135
1136  BFD_ASSERT (name);
1137
1138  fd = open (name, O_RDONLY);
1139  if (fd < 0)
1140    return FALSE;
1141
1142  while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1143    file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1144
1145  close (fd);
1146
1147  return crc == file_crc;
1148}
1149
1150
1151/*
1152INTERNAL_FUNCTION
1153	find_separate_debug_file
1154
1155SYNOPSIS
1156	char *find_separate_debug_file (bfd *abfd);
1157
1158DESCRIPTION
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.
1165*/
1166
1167static char *
1168find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1169{
1170  char *basename;
1171  char *dir;
1172  char *debugfile;
1173  unsigned long crc32;
1174  int i;
1175
1176  BFD_ASSERT (abfd);
1177  if (debug_file_directory == NULL)
1178    debug_file_directory = ".";
1179
1180  /* BFD may have been opened from a stream.  */
1181  if (! abfd->filename)
1182    return NULL;
1183
1184  basename = get_debug_link_info (abfd, & crc32);
1185  if (basename == NULL)
1186    return NULL;
1187
1188  if (strlen (basename) < 1)
1189    {
1190      free (basename);
1191      return NULL;
1192    }
1193
1194  dir = strdup (abfd->filename);
1195  if (dir == NULL)
1196    {
1197      free (basename);
1198      return NULL;
1199    }
1200  BFD_ASSERT (strlen (dir) != 0);
1201
1202  /* Strip off filename part.  */
1203  for (i = strlen (dir) - 1; i >= 0; i--)
1204    if (IS_DIR_SEPARATOR (dir[i]))
1205      break;
1206
1207  dir[i + 1] = '\0';
1208  BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
1209
1210  debugfile = malloc (strlen (debug_file_directory) + 1
1211		      + strlen (dir)
1212		      + strlen (".debug/")
1213		      + strlen (basename)
1214		      + 1);
1215  if (debugfile == NULL)
1216    {
1217      free (basename);
1218      free (dir);
1219      return NULL;
1220    }
1221
1222  /* First try in the same directory as the original file:  */
1223  strcpy (debugfile, dir);
1224  strcat (debugfile, basename);
1225
1226  if (separate_debug_file_exists (debugfile, crc32))
1227    {
1228      free (basename);
1229      free (dir);
1230      return debugfile;
1231    }
1232
1233  /* Then try in a subdirectory called .debug.  */
1234  strcpy (debugfile, dir);
1235  strcat (debugfile, ".debug/");
1236  strcat (debugfile, basename);
1237
1238  if (separate_debug_file_exists (debugfile, crc32))
1239    {
1240      free (basename);
1241      free (dir);
1242      return debugfile;
1243    }
1244
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);
1254
1255  if (separate_debug_file_exists (debugfile, crc32))
1256    {
1257      free (basename);
1258      free (dir);
1259      return debugfile;
1260    }
1261
1262  free (debugfile);
1263  free (basename);
1264  free (dir);
1265  return NULL;
1266}
1267
1268
1269/*
1270FUNCTION
1271	bfd_follow_gnu_debuglink
1272
1273SYNOPSIS
1274	char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1275
1276DESCRIPTION
1277
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.
1284
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].
1288
1289RETURNS
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.
1293*/
1294
1295char *
1296bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1297{
1298  return find_separate_debug_file (abfd, dir);
1299}
1300
1301/*
1302FUNCTION
1303	bfd_create_gnu_debuglink_section
1304
1305SYNOPSIS
1306	struct bfd_section *bfd_create_gnu_debuglink_section
1307	  (bfd *abfd, const char *filename);
1308
1309DESCRIPTION
1310
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}.
1313
1314RETURNS
1315	A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1316	returned and bfd_error is set.
1317*/
1318
1319asection *
1320bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1321{
1322  asection *sect;
1323  bfd_size_type debuglink_size;
1324
1325  if (abfd == NULL || filename == NULL)
1326    {
1327      bfd_set_error (bfd_error_invalid_operation);
1328      return NULL;
1329    }
1330
1331  /* Strip off any path components in filename.  */
1332  filename = lbasename (filename);
1333
1334  sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1335  if (sect)
1336    {
1337      /* Section already exists.  */
1338      bfd_set_error (bfd_error_invalid_operation);
1339      return NULL;
1340    }
1341
1342  sect = bfd_make_section (abfd, GNU_DEBUGLINK);
1343  if (sect == NULL)
1344    return NULL;
1345
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;
1350
1351
1352  debuglink_size = strlen (filename) + 1;
1353  debuglink_size += 3;
1354  debuglink_size &= ~3;
1355  debuglink_size += 4;
1356
1357  if (! bfd_set_section_size (abfd, sect, debuglink_size))
1358    /* XXX Should we delete the section from the bfd ?  */
1359    return NULL;
1360
1361  return sect;
1362}
1363
1364
1365/*
1366FUNCTION
1367	bfd_fill_in_gnu_debuglink_section
1368
1369SYNOPSIS
1370	bfd_boolean bfd_fill_in_gnu_debuglink_section
1371	  (bfd *abfd, struct bfd_section *sect, const char *filename);
1372
1373DESCRIPTION
1374
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.
1379
1380RETURNS
1381	<<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1382	and bfd_error is set.
1383*/
1384
1385bfd_boolean
1386bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1387				   struct bfd_section *sect,
1388				   const char *filename)
1389{
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;
1397
1398  if (abfd == NULL || sect == NULL || filename == NULL)
1399    {
1400      bfd_set_error (bfd_error_invalid_operation);
1401      return FALSE;
1402    }
1403
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)
1412    {
1413      bfd_set_error (bfd_error_system_call);
1414      return FALSE;
1415    }
1416
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);
1421
1422  /* Strip off any path components in filename,
1423     now that we no longer need them.  */
1424  filename = lbasename (filename);
1425
1426  debuglink_size = strlen (filename) + 1;
1427  debuglink_size += 3;
1428  debuglink_size &= ~3;
1429  debuglink_size += 4;
1430
1431  contents = malloc (debuglink_size);
1432  if (contents == NULL)
1433    {
1434      /* XXX Should we delete the section from the bfd ?  */
1435      bfd_set_error (bfd_error_no_memory);
1436      return FALSE;
1437    }
1438
1439  strcpy (contents, filename);
1440  crc_offset = debuglink_size - 4;
1441
1442  bfd_put_32 (abfd, crc32, contents + crc_offset);
1443
1444  if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1445    {
1446      /* XXX Should we delete the section from the bfd ?  */
1447      free (contents);
1448      return FALSE;
1449    }
1450
1451  return TRUE;
1452}
1453