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, 2007
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 "sysdep.h"
25#include "bfd.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  if (abfd->memory)
119    {
120      bfd_hash_table_free (&abfd->section_htab);
121      objalloc_free ((struct objalloc *) abfd->memory);
122    }
123  free (abfd);
124}
125
126/* Free objalloc memory.  */
127
128bfd_boolean
129_bfd_free_cached_info (bfd *abfd)
130{
131  if (abfd->memory)
132    {
133      bfd_hash_table_free (&abfd->section_htab);
134      objalloc_free ((struct objalloc *) abfd->memory);
135
136      abfd->sections = NULL;
137      abfd->section_last = NULL;
138      abfd->outsymbols = NULL;
139      abfd->tdata.any = NULL;
140      abfd->usrdata = NULL;
141      abfd->memory = NULL;
142    }
143
144  return TRUE;
145}
146
147/*
148SECTION
149	Opening and closing BFDs
150
151SUBSECTION
152	Functions for opening and closing
153*/
154
155/*
156FUNCTION
157	bfd_fopen
158
159SYNOPSIS
160	bfd *bfd_fopen (const char *filename, const char *target,
161                        const char *mode, int fd);
162
163DESCRIPTION
164	Open the file @var{filename} with the target @var{target}.
165	Return a pointer to the created BFD.  If @var{fd} is not -1,
166	then <<fdopen>> is used to open the file; otherwise, <<fopen>>
167	is used.  @var{mode} is passed directly to <<fopen>> or
168	<<fdopen>>.
169
170	Calls <<bfd_find_target>>, so @var{target} is interpreted as by
171	that function.
172
173	The new BFD is marked as cacheable iff @var{fd} is -1.
174
175	If <<NULL>> is returned then an error has occured.   Possible errors
176	are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
177	<<system_call>> error.
178*/
179
180bfd *
181bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
182{
183  bfd *nbfd;
184  const bfd_target *target_vec;
185
186  nbfd = _bfd_new_bfd ();
187  if (nbfd == NULL)
188    return NULL;
189
190  target_vec = bfd_find_target (target, nbfd);
191  if (target_vec == NULL)
192    {
193      _bfd_delete_bfd (nbfd);
194      return NULL;
195    }
196
197#ifdef HAVE_FDOPEN
198  if (fd != -1)
199    nbfd->iostream = fdopen (fd, mode);
200  else
201#endif
202    nbfd->iostream = real_fopen (filename, mode);
203  if (nbfd->iostream == NULL)
204    {
205      bfd_set_error (bfd_error_system_call);
206      _bfd_delete_bfd (nbfd);
207      return NULL;
208    }
209
210  /* OK, put everything where it belongs.  */
211  nbfd->filename = filename;
212
213  /* Figure out whether the user is opening the file for reading,
214     writing, or both, by looking at the MODE argument.  */
215  if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
216      && mode[1] == '+')
217    nbfd->direction = both_direction;
218  else if (mode[0] == 'r')
219    nbfd->direction = read_direction;
220  else
221    nbfd->direction = write_direction;
222
223  if (! bfd_cache_init (nbfd))
224    {
225      _bfd_delete_bfd (nbfd);
226      return NULL;
227    }
228  nbfd->opened_once = TRUE;
229  /* If we opened the file by name, mark it cacheable; we can close it
230     and reopen it later.  However, if a file descriptor was provided,
231     then it may have been opened with special flags that make it
232     unsafe to close and reopen the file.  */
233  if (fd == -1)
234    (void) bfd_set_cacheable (nbfd, TRUE);
235
236  return nbfd;
237}
238
239/*
240FUNCTION
241	bfd_openr
242
243SYNOPSIS
244	bfd *bfd_openr (const char *filename, const char *target);
245
246DESCRIPTION
247	Open the file @var{filename} (using <<fopen>>) with the target
248	@var{target}.  Return a pointer to the created BFD.
249
250	Calls <<bfd_find_target>>, so @var{target} is interpreted as by
251	that function.
252
253	If <<NULL>> is returned then an error has occured.   Possible errors
254	are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
255	<<system_call>> error.
256*/
257
258bfd *
259bfd_openr (const char *filename, const char *target)
260{
261  return bfd_fopen (filename, target, FOPEN_RB, -1);
262}
263
264/* Don't try to `optimize' this function:
265
266   o - We lock using stack space so that interrupting the locking
267       won't cause a storage leak.
268   o - We open the file stream last, since we don't want to have to
269       close it if anything goes wrong.  Closing the stream means closing
270       the file descriptor too, even though we didn't open it.  */
271/*
272FUNCTION
273	bfd_fdopenr
274
275SYNOPSIS
276	bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
277
278DESCRIPTION
279	<<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
280	<<fopen>>.  It opens a BFD on a file already described by the
281	@var{fd} supplied.
282
283	When the file is later <<bfd_close>>d, the file descriptor will
284	be closed.  If the caller desires that this file descriptor be
285	cached by BFD (opened as needed, closed as needed to free
286	descriptors for other opens), with the supplied @var{fd} used as
287	an initial file descriptor (but subject to closure at any time),
288	call bfd_set_cacheable(bfd, 1) on the returned BFD.  The default
289	is to assume no caching; the file descriptor will remain open
290	until <<bfd_close>>, and will not be affected by BFD operations
291	on other files.
292
293	Possible errors are <<bfd_error_no_memory>>,
294	<<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
295*/
296
297bfd *
298bfd_fdopenr (const char *filename, const char *target, int fd)
299{
300  const char *mode;
301#if defined(HAVE_FCNTL) && defined(F_GETFL)
302  int fdflags;
303#endif
304
305#if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
306  mode = FOPEN_RUB; /* Assume full access.  */
307#else
308  fdflags = fcntl (fd, F_GETFL, NULL);
309  if (fdflags == -1)
310    {
311      bfd_set_error (bfd_error_system_call);
312      return NULL;
313    }
314
315  /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
316  switch (fdflags & (O_ACCMODE))
317    {
318    case O_RDONLY: mode = FOPEN_RB; break;
319    case O_WRONLY: mode = FOPEN_RUB; break;
320    case O_RDWR:   mode = FOPEN_RUB; break;
321    default: abort ();
322    }
323#endif
324
325  return bfd_fopen (filename, target, mode, fd);
326}
327
328/*
329FUNCTION
330	bfd_openstreamr
331
332SYNOPSIS
333	bfd *bfd_openstreamr (const char *, const char *, void *);
334
335DESCRIPTION
336
337	Open a BFD for read access on an existing stdio stream.  When
338	the BFD is passed to <<bfd_close>>, the stream will be closed.
339*/
340
341bfd *
342bfd_openstreamr (const char *filename, const char *target, void *streamarg)
343{
344  FILE *stream = streamarg;
345  bfd *nbfd;
346  const bfd_target *target_vec;
347
348  nbfd = _bfd_new_bfd ();
349  if (nbfd == NULL)
350    return NULL;
351
352  target_vec = bfd_find_target (target, nbfd);
353  if (target_vec == NULL)
354    {
355      _bfd_delete_bfd (nbfd);
356      return NULL;
357    }
358
359  nbfd->iostream = stream;
360  nbfd->filename = filename;
361  nbfd->direction = read_direction;
362
363  if (! bfd_cache_init (nbfd))
364    {
365      _bfd_delete_bfd (nbfd);
366      return NULL;
367    }
368
369  return nbfd;
370}
371
372/*
373FUNCTION
374	bfd_openr_iovec
375
376SYNOPSIS
377        bfd *bfd_openr_iovec (const char *filename, const char *target,
378                              void *(*open) (struct bfd *nbfd,
379                                             void *open_closure),
380                              void *open_closure,
381                              file_ptr (*pread) (struct bfd *nbfd,
382                                                 void *stream,
383                                                 void *buf,
384                                                 file_ptr nbytes,
385                                                 file_ptr offset),
386                              int (*close) (struct bfd *nbfd,
387                                            void *stream),
388			      int (*stat) (struct bfd *abfd,
389					   void *stream,
390					   struct stat *sb));
391
392DESCRIPTION
393
394        Create and return a BFD backed by a read-only @var{stream}.
395        The @var{stream} is created using @var{open}, accessed using
396        @var{pread} and destroyed using @var{close}.
397
398	Calls <<bfd_find_target>>, so @var{target} is interpreted as by
399	that function.
400
401	Calls @var{open} (which can call <<bfd_zalloc>> and
402	<<bfd_get_filename>>) to obtain the read-only stream backing
403	the BFD.  @var{open} either succeeds returning the
404	non-<<NULL>> @var{stream}, or fails returning <<NULL>>
405	(setting <<bfd_error>>).
406
407	Calls @var{pread} to request @var{nbytes} of data from
408	@var{stream} starting at @var{offset} (e.g., via a call to
409	<<bfd_read>>).  @var{pread} either succeeds returning the
410	number of bytes read (which can be less than @var{nbytes} when
411	end-of-file), or fails returning -1 (setting <<bfd_error>>).
412
413	Calls @var{close} when the BFD is later closed using
414	<<bfd_close>>.  @var{close} either succeeds returning 0, or
415	fails returning -1 (setting <<bfd_error>>).
416
417	Calls @var{stat} to fill in a stat structure for bfd_stat,
418	bfd_get_size, and bfd_get_mtime calls.  @var{stat} returns 0
419	on success, or returns -1 on failure (setting <<bfd_error>>).
420
421	If <<bfd_openr_iovec>> returns <<NULL>> then an error has
422	occurred.  Possible errors are <<bfd_error_no_memory>>,
423	<<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
424
425*/
426
427struct opncls
428{
429  void *stream;
430  file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
431		     file_ptr nbytes, file_ptr offset);
432  int (*close) (struct bfd *abfd, void *stream);
433  int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
434  file_ptr where;
435};
436
437static file_ptr
438opncls_btell (struct bfd *abfd)
439{
440  struct opncls *vec = abfd->iostream;
441  return vec->where;
442}
443
444static int
445opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
446{
447  struct opncls *vec = abfd->iostream;
448  switch (whence)
449    {
450    case SEEK_SET: vec->where = offset; break;
451    case SEEK_CUR: vec->where += offset; break;
452    case SEEK_END: return -1;
453    }
454  return 0;
455}
456
457static file_ptr
458opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
459{
460  struct opncls *vec = abfd->iostream;
461  file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
462  if (nread < 0)
463    return nread;
464  vec->where += nread;
465  return nread;
466}
467
468static file_ptr
469opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
470	      const void *where ATTRIBUTE_UNUSED,
471	      file_ptr nbytes ATTRIBUTE_UNUSED)
472{
473  return -1;
474}
475
476static int
477opncls_bclose (struct bfd *abfd)
478{
479  struct opncls *vec = abfd->iostream;
480  /* Since the VEC's memory is bound to the bfd deleting the bfd will
481     free it.  */
482  int status = 0;
483  if (vec->close != NULL)
484    status = (vec->close) (abfd, vec->stream);
485  abfd->iostream = NULL;
486  return status;
487}
488
489static int
490opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
491{
492  return 0;
493}
494
495static int
496opncls_bstat (struct bfd *abfd, struct stat *sb)
497{
498  struct opncls *vec = abfd->iostream;
499
500  memset (sb, 0, sizeof (*sb));
501  if (vec->stat == NULL)
502    return 0;
503
504  return (vec->stat) (abfd, vec->stream, sb);
505}
506
507static const struct bfd_iovec opncls_iovec = {
508  &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
509  &opncls_bclose, &opncls_bflush, &opncls_bstat
510};
511
512bfd *
513bfd_openr_iovec (const char *filename, const char *target,
514		 void *(*open) (struct bfd *nbfd,
515				void *open_closure),
516		 void *open_closure,
517		 file_ptr (*pread) (struct bfd *abfd,
518				    void *stream,
519				    void *buf,
520				    file_ptr nbytes,
521				    file_ptr offset),
522		 int (*close) (struct bfd *nbfd,
523			       void *stream),
524		 int (*stat) (struct bfd *abfd,
525			      void *stream,
526			      struct stat *sb))
527{
528  bfd *nbfd;
529  const bfd_target *target_vec;
530  struct opncls *vec;
531  void *stream;
532
533  nbfd = _bfd_new_bfd ();
534  if (nbfd == NULL)
535    return NULL;
536
537  target_vec = bfd_find_target (target, nbfd);
538  if (target_vec == NULL)
539    {
540      _bfd_delete_bfd (nbfd);
541      return NULL;
542    }
543
544  nbfd->filename = filename;
545  nbfd->direction = read_direction;
546
547  stream = open (nbfd, open_closure);
548  if (stream == NULL)
549    {
550      _bfd_delete_bfd (nbfd);
551      return NULL;
552    }
553
554  vec = bfd_zalloc (nbfd, sizeof (struct opncls));
555  vec->stream = stream;
556  vec->pread = pread;
557  vec->close = close;
558  vec->stat = stat;
559
560  nbfd->iovec = &opncls_iovec;
561  nbfd->iostream = vec;
562
563  return nbfd;
564}
565
566/* bfd_openw -- open for writing.
567   Returns a pointer to a freshly-allocated BFD on success, or NULL.
568
569   See comment by bfd_fdopenr before you try to modify this function.  */
570
571/*
572FUNCTION
573	bfd_openw
574
575SYNOPSIS
576	bfd *bfd_openw (const char *filename, const char *target);
577
578DESCRIPTION
579	Create a BFD, associated with file @var{filename}, using the
580	file format @var{target}, and return a pointer to it.
581
582	Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
583	<<bfd_error_invalid_target>>.
584*/
585
586bfd *
587bfd_openw (const char *filename, const char *target)
588{
589  bfd *nbfd;
590  const bfd_target *target_vec;
591
592  /* nbfd has to point to head of malloc'ed block so that bfd_close may
593     reclaim it correctly.  */
594  nbfd = _bfd_new_bfd ();
595  if (nbfd == NULL)
596    return NULL;
597
598  target_vec = bfd_find_target (target, nbfd);
599  if (target_vec == NULL)
600    {
601      _bfd_delete_bfd (nbfd);
602      return NULL;
603    }
604
605  nbfd->filename = filename;
606  nbfd->direction = write_direction;
607
608  if (bfd_open_file (nbfd) == NULL)
609    {
610      /* File not writeable, etc.  */
611      bfd_set_error (bfd_error_system_call);
612      _bfd_delete_bfd (nbfd);
613      return NULL;
614  }
615
616  return nbfd;
617}
618
619/*
620
621FUNCTION
622	bfd_close
623
624SYNOPSIS
625	bfd_boolean bfd_close (bfd *abfd);
626
627DESCRIPTION
628
629	Close a BFD. If the BFD was open for writing, then pending
630	operations are completed and the file written out and closed.
631	If the created file is executable, then <<chmod>> is called
632	to mark it as such.
633
634	All memory attached to the BFD is released.
635
636	The file descriptor associated with the BFD is closed (even
637	if it was passed in to BFD by <<bfd_fdopenr>>).
638
639RETURNS
640	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
641*/
642
643
644bfd_boolean
645bfd_close (bfd *abfd)
646{
647  bfd_boolean ret;
648
649  if (bfd_write_p (abfd))
650    {
651      if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
652	return FALSE;
653    }
654
655  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
656    return FALSE;
657
658  /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
659     vector.  */
660  if (!(abfd->flags & BFD_IN_MEMORY))
661    ret = abfd->iovec->bclose (abfd);
662  else
663    ret = TRUE;
664
665  /* If the file was open for writing and is now executable,
666     make it so.  */
667  if (ret
668      && abfd->direction == write_direction
669      && abfd->flags & EXEC_P)
670    {
671      struct stat buf;
672
673      if (stat (abfd->filename, &buf) == 0)
674	{
675	  unsigned int mask = umask (0);
676
677	  umask (mask);
678	  chmod (abfd->filename,
679		 (0777
680		  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
681	}
682    }
683
684  _bfd_delete_bfd (abfd);
685
686  return ret;
687}
688
689/*
690FUNCTION
691	bfd_close_all_done
692
693SYNOPSIS
694	bfd_boolean bfd_close_all_done (bfd *);
695
696DESCRIPTION
697	Close a BFD.  Differs from <<bfd_close>> since it does not
698	complete any pending operations.  This routine would be used
699	if the application had just used BFD for swapping and didn't
700	want to use any of the writing code.
701
702	If the created file is executable, then <<chmod>> is called
703	to mark it as such.
704
705	All memory attached to the BFD is released.
706
707RETURNS
708	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
709*/
710
711bfd_boolean
712bfd_close_all_done (bfd *abfd)
713{
714  bfd_boolean ret;
715
716  ret = bfd_cache_close (abfd);
717
718  /* If the file was open for writing and is now executable,
719     make it so.  */
720  if (ret
721      && abfd->direction == write_direction
722      && abfd->flags & EXEC_P)
723    {
724      struct stat buf;
725
726      if (stat (abfd->filename, &buf) == 0)
727	{
728	  unsigned int mask = umask (0);
729
730	  umask (mask);
731	  chmod (abfd->filename,
732		 (0777
733		  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
734	}
735    }
736
737  _bfd_delete_bfd (abfd);
738
739  return ret;
740}
741
742/*
743FUNCTION
744	bfd_create
745
746SYNOPSIS
747	bfd *bfd_create (const char *filename, bfd *templ);
748
749DESCRIPTION
750	Create a new BFD in the manner of <<bfd_openw>>, but without
751	opening a file. The new BFD takes the target from the target
752	used by @var{template}. The format is always set to <<bfd_object>>.
753*/
754
755bfd *
756bfd_create (const char *filename, bfd *templ)
757{
758  bfd *nbfd;
759
760  nbfd = _bfd_new_bfd ();
761  if (nbfd == NULL)
762    return NULL;
763  nbfd->filename = filename;
764  if (templ)
765    nbfd->xvec = templ->xvec;
766  nbfd->direction = no_direction;
767  bfd_set_format (nbfd, bfd_object);
768
769  return nbfd;
770}
771
772/*
773FUNCTION
774	bfd_make_writable
775
776SYNOPSIS
777	bfd_boolean bfd_make_writable (bfd *abfd);
778
779DESCRIPTION
780	Takes a BFD as created by <<bfd_create>> and converts it
781	into one like as returned by <<bfd_openw>>.  It does this
782	by converting the BFD to BFD_IN_MEMORY.  It's assumed that
783	you will call <<bfd_make_readable>> on this bfd later.
784
785RETURNS
786	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
787*/
788
789bfd_boolean
790bfd_make_writable (bfd *abfd)
791{
792  struct bfd_in_memory *bim;
793
794  if (abfd->direction != no_direction)
795    {
796      bfd_set_error (bfd_error_invalid_operation);
797      return FALSE;
798    }
799
800  bim = bfd_malloc (sizeof (struct bfd_in_memory));
801  abfd->iostream = bim;
802  /* bfd_bwrite will grow these as needed.  */
803  bim->size = 0;
804  bim->buffer = 0;
805
806  abfd->flags |= BFD_IN_MEMORY;
807  abfd->direction = write_direction;
808  abfd->where = 0;
809
810  return TRUE;
811}
812
813/*
814FUNCTION
815	bfd_make_readable
816
817SYNOPSIS
818	bfd_boolean bfd_make_readable (bfd *abfd);
819
820DESCRIPTION
821	Takes a BFD as created by <<bfd_create>> and
822	<<bfd_make_writable>> and converts it into one like as
823	returned by <<bfd_openr>>.  It does this by writing the
824	contents out to the memory buffer, then reversing the
825	direction.
826
827RETURNS
828	<<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
829
830bfd_boolean
831bfd_make_readable (bfd *abfd)
832{
833  if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
834    {
835      bfd_set_error (bfd_error_invalid_operation);
836      return FALSE;
837    }
838
839  if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
840    return FALSE;
841
842  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
843    return FALSE;
844
845
846  abfd->arch_info = &bfd_default_arch_struct;
847
848  abfd->where = 0;
849  abfd->format = bfd_unknown;
850  abfd->my_archive = NULL;
851  abfd->origin = 0;
852  abfd->opened_once = FALSE;
853  abfd->output_has_begun = FALSE;
854  abfd->section_count = 0;
855  abfd->usrdata = NULL;
856  abfd->cacheable = FALSE;
857  abfd->flags = BFD_IN_MEMORY;
858  abfd->mtime_set = FALSE;
859
860  abfd->target_defaulted = TRUE;
861  abfd->direction = read_direction;
862  abfd->sections = 0;
863  abfd->symcount = 0;
864  abfd->outsymbols = 0;
865  abfd->tdata.any = 0;
866
867  bfd_section_list_clear (abfd);
868  bfd_check_format (abfd, bfd_object);
869
870  return TRUE;
871}
872
873/*
874INTERNAL_FUNCTION
875	bfd_alloc
876
877SYNOPSIS
878	void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
879
880DESCRIPTION
881	Allocate a block of @var{wanted} bytes of memory attached to
882	<<abfd>> and return a pointer to it.
883*/
884
885void *
886bfd_alloc (bfd *abfd, bfd_size_type size)
887{
888  void *ret;
889
890  if (size != (unsigned long) size)
891    {
892      bfd_set_error (bfd_error_no_memory);
893      return NULL;
894    }
895
896  ret = objalloc_alloc (abfd->memory, (unsigned long) size);
897  if (ret == NULL)
898    bfd_set_error (bfd_error_no_memory);
899  return ret;
900}
901
902/*
903INTERNAL_FUNCTION
904	bfd_alloc2
905
906SYNOPSIS
907	void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
908
909DESCRIPTION
910	Allocate a block of @var{nmemb} elements of @var{size} bytes each
911	of memory attached to <<abfd>> and return a pointer to it.
912*/
913
914void *
915bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
916{
917  void *ret;
918
919  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
920      && size != 0
921      && nmemb > ~(bfd_size_type) 0 / size)
922    {
923      bfd_set_error (bfd_error_no_memory);
924      return NULL;
925    }
926
927  size *= nmemb;
928
929  if (size != (unsigned long) size)
930    {
931      bfd_set_error (bfd_error_no_memory);
932      return NULL;
933    }
934
935  ret = objalloc_alloc (abfd->memory, (unsigned long) size);
936  if (ret == NULL)
937    bfd_set_error (bfd_error_no_memory);
938  return ret;
939}
940
941/*
942INTERNAL_FUNCTION
943	bfd_zalloc
944
945SYNOPSIS
946	void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
947
948DESCRIPTION
949	Allocate a block of @var{wanted} bytes of zeroed memory
950	attached to <<abfd>> and return a pointer to it.
951*/
952
953void *
954bfd_zalloc (bfd *abfd, bfd_size_type size)
955{
956  void *res;
957
958  res = bfd_alloc (abfd, size);
959  if (res)
960    memset (res, 0, (size_t) size);
961  return res;
962}
963
964/*
965INTERNAL_FUNCTION
966	bfd_zalloc2
967
968SYNOPSIS
969	void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
970
971DESCRIPTION
972	Allocate a block of @var{nmemb} elements of @var{size} bytes each
973	of zeroed memory attached to <<abfd>> and return a pointer to it.
974*/
975
976void *
977bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
978{
979  void *res;
980
981  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
982      && size != 0
983      && nmemb > ~(bfd_size_type) 0 / size)
984    {
985      bfd_set_error (bfd_error_no_memory);
986      return NULL;
987    }
988
989  size *= nmemb;
990
991  res = bfd_alloc (abfd, size);
992  if (res)
993    memset (res, 0, (size_t) size);
994  return res;
995}
996
997/* Free a block allocated for a BFD.
998   Note:  Also frees all more recently allocated blocks!  */
999
1000void
1001bfd_release (bfd *abfd, void *block)
1002{
1003  objalloc_free_block ((struct objalloc *) abfd->memory, block);
1004}
1005
1006
1007/*
1008   GNU Extension: separate debug-info files
1009
1010   The idea here is that a special section called .gnu_debuglink might be
1011   embedded in a binary file, which indicates that some *other* file
1012   contains the real debugging information. This special section contains a
1013   filename and CRC32 checksum, which we read and resolve to another file,
1014   if it exists.
1015
1016   This facilitates "optional" provision of debugging information, without
1017   having to provide two complete copies of every binary object (with and
1018   without debug symbols).
1019*/
1020
1021#define GNU_DEBUGLINK	".gnu_debuglink"
1022/*
1023FUNCTION
1024	bfd_calc_gnu_debuglink_crc32
1025
1026SYNOPSIS
1027	unsigned long bfd_calc_gnu_debuglink_crc32
1028	  (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1029
1030DESCRIPTION
1031	Computes a CRC value as used in the .gnu_debuglink section.
1032	Advances the previously computed @var{crc} value by computing
1033	and adding in the crc32 for @var{len} bytes of @var{buf}.
1034
1035RETURNS
1036	Return the updated CRC32 value.
1037*/
1038
1039unsigned long
1040bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1041			      const unsigned char *buf,
1042			      bfd_size_type len)
1043{
1044  static const unsigned long crc32_table[256] =
1045    {
1046      0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1047      0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1048      0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1049      0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1050      0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1051      0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1052      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1053      0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1054      0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1055      0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1056      0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1057      0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1058      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1059      0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1060      0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1061      0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1062      0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1063      0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1064      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1065      0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1066      0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1067      0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1068      0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1069      0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1070      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1071      0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1072      0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1073      0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1074      0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1075      0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1076      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1077      0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1078      0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1079      0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1080      0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1081      0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1082      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1083      0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1084      0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1085      0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1086      0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1087      0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1088      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1089      0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1090      0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1091      0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1092      0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1093      0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1094      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1095      0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1096      0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1097      0x2d02ef8d
1098    };
1099  const unsigned char *end;
1100
1101  crc = ~crc & 0xffffffff;
1102  for (end = buf + len; buf < end; ++ buf)
1103    crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1104  return ~crc & 0xffffffff;;
1105}
1106
1107
1108/*
1109INTERNAL_FUNCTION
1110	get_debug_link_info
1111
1112SYNOPSIS
1113	char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1114
1115DESCRIPTION
1116	fetch the filename and CRC32 value for any separate debuginfo
1117	associated with @var{abfd}. Return NULL if no such info found,
1118	otherwise return filename and update @var{crc32_out}.
1119*/
1120
1121static char *
1122get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1123{
1124  asection *sect;
1125  unsigned long crc32;
1126  bfd_byte *contents;
1127  int crc_offset;
1128  char *name;
1129
1130  BFD_ASSERT (abfd);
1131  BFD_ASSERT (crc32_out);
1132
1133  sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1134
1135  if (sect == NULL)
1136    return NULL;
1137
1138  if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1139    {
1140      if (contents != NULL)
1141	free (contents);
1142      return NULL;
1143    }
1144
1145  /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1146  name = (char *) contents;
1147  crc_offset = strlen (name) + 1;
1148  crc_offset = (crc_offset + 3) & ~3;
1149
1150  crc32 = bfd_get_32 (abfd, contents + crc_offset);
1151
1152  *crc32_out = crc32;
1153  return name;
1154}
1155
1156/*
1157INTERNAL_FUNCTION
1158	separate_debug_file_exists
1159
1160SYNOPSIS
1161	bfd_boolean separate_debug_file_exists
1162	  (char *name, unsigned long crc32);
1163
1164DESCRIPTION
1165	Checks to see if @var{name} is a file and if its contents
1166	match @var{crc32}.
1167*/
1168
1169static bfd_boolean
1170separate_debug_file_exists (const char *name, const unsigned long crc)
1171{
1172  static unsigned char buffer [8 * 1024];
1173  unsigned long file_crc = 0;
1174  int fd;
1175  bfd_size_type count;
1176
1177  BFD_ASSERT (name);
1178
1179  fd = open (name, O_RDONLY);
1180  if (fd < 0)
1181    return FALSE;
1182
1183  while ((count = read (fd, buffer, sizeof (buffer))) > 0)
1184    file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1185
1186  close (fd);
1187
1188  return crc == file_crc;
1189}
1190
1191
1192/*
1193INTERNAL_FUNCTION
1194	find_separate_debug_file
1195
1196SYNOPSIS
1197	char *find_separate_debug_file (bfd *abfd);
1198
1199DESCRIPTION
1200	Searches @var{abfd} for a reference to separate debugging
1201	information, scans various locations in the filesystem, including
1202	the file tree rooted at @var{debug_file_directory}, and returns a
1203	filename of such debugging information if the file is found and has
1204	matching CRC32.  Returns NULL if no reference to debugging file
1205	exists, or file cannot be found.
1206*/
1207
1208static char *
1209find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1210{
1211  char *basename;
1212  char *dir;
1213  char *debugfile;
1214  unsigned long crc32;
1215  int i;
1216
1217  BFD_ASSERT (abfd);
1218  if (debug_file_directory == NULL)
1219    debug_file_directory = ".";
1220
1221  /* BFD may have been opened from a stream.  */
1222  if (! abfd->filename)
1223    return NULL;
1224
1225  basename = get_debug_link_info (abfd, & crc32);
1226  if (basename == NULL)
1227    return NULL;
1228
1229  if (strlen (basename) < 1)
1230    {
1231      free (basename);
1232      return NULL;
1233    }
1234
1235  dir = strdup (abfd->filename);
1236  if (dir == NULL)
1237    {
1238      free (basename);
1239      return NULL;
1240    }
1241  BFD_ASSERT (strlen (dir) != 0);
1242
1243  /* Strip off filename part.  */
1244  for (i = strlen (dir) - 1; i >= 0; i--)
1245    if (IS_DIR_SEPARATOR (dir[i]))
1246      break;
1247
1248  dir[i + 1] = '\0';
1249  BFD_ASSERT (dir[i] == '/' || dir[0] == '\0');
1250
1251  debugfile = malloc (strlen (debug_file_directory) + 1
1252		      + strlen (dir)
1253		      + strlen (".debug/")
1254		      + strlen (basename)
1255		      + 1);
1256  if (debugfile == NULL)
1257    {
1258      free (basename);
1259      free (dir);
1260      return NULL;
1261    }
1262
1263  /* First try in the same directory as the original file:  */
1264  strcpy (debugfile, dir);
1265  strcat (debugfile, basename);
1266
1267  if (separate_debug_file_exists (debugfile, crc32))
1268    {
1269      free (basename);
1270      free (dir);
1271      return debugfile;
1272    }
1273
1274  /* Then try in a subdirectory called .debug.  */
1275  strcpy (debugfile, dir);
1276  strcat (debugfile, ".debug/");
1277  strcat (debugfile, basename);
1278
1279  if (separate_debug_file_exists (debugfile, crc32))
1280    {
1281      free (basename);
1282      free (dir);
1283      return debugfile;
1284    }
1285
1286  /* Then try in the global debugfile directory.  */
1287  strcpy (debugfile, debug_file_directory);
1288  i = strlen (debug_file_directory) - 1;
1289  if (i > 0
1290      && debug_file_directory[i] != '/'
1291      && dir[0] != '/')
1292    strcat (debugfile, "/");
1293  strcat (debugfile, dir);
1294  strcat (debugfile, basename);
1295
1296  if (separate_debug_file_exists (debugfile, crc32))
1297    {
1298      free (basename);
1299      free (dir);
1300      return debugfile;
1301    }
1302
1303  free (debugfile);
1304  free (basename);
1305  free (dir);
1306  return NULL;
1307}
1308
1309
1310/*
1311FUNCTION
1312	bfd_follow_gnu_debuglink
1313
1314SYNOPSIS
1315	char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1316
1317DESCRIPTION
1318
1319	Takes a BFD and searches it for a .gnu_debuglink section.  If this
1320	section is found, it examines the section for the name and checksum
1321	of a '.debug' file containing auxiliary debugging information.  It
1322	then searches the filesystem for this .debug file in some standard
1323	locations, including the directory tree rooted at @var{dir}, and if
1324	found returns the full filename.
1325
1326	If @var{dir} is NULL, it will search a default path configured into
1327	libbfd at build time.  [XXX this feature is not currently
1328	implemented].
1329
1330RETURNS
1331	<<NULL>> on any errors or failure to locate the .debug file,
1332	otherwise a pointer to a heap-allocated string containing the
1333	filename.  The caller is responsible for freeing this string.
1334*/
1335
1336char *
1337bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1338{
1339  return find_separate_debug_file (abfd, dir);
1340}
1341
1342/*
1343FUNCTION
1344	bfd_create_gnu_debuglink_section
1345
1346SYNOPSIS
1347	struct bfd_section *bfd_create_gnu_debuglink_section
1348	  (bfd *abfd, const char *filename);
1349
1350DESCRIPTION
1351
1352	Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1353	to be big enough to contain a link to the specified @var{filename}.
1354
1355RETURNS
1356	A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1357	returned and bfd_error is set.
1358*/
1359
1360asection *
1361bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1362{
1363  asection *sect;
1364  bfd_size_type debuglink_size;
1365  flagword flags;
1366
1367  if (abfd == NULL || filename == NULL)
1368    {
1369      bfd_set_error (bfd_error_invalid_operation);
1370      return NULL;
1371    }
1372
1373  /* Strip off any path components in filename.  */
1374  filename = lbasename (filename);
1375
1376  sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1377  if (sect)
1378    {
1379      /* Section already exists.  */
1380      bfd_set_error (bfd_error_invalid_operation);
1381      return NULL;
1382    }
1383
1384  flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1385  sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1386  if (sect == NULL)
1387    return NULL;
1388
1389  debuglink_size = strlen (filename) + 1;
1390  debuglink_size += 3;
1391  debuglink_size &= ~3;
1392  debuglink_size += 4;
1393
1394  if (! bfd_set_section_size (abfd, sect, debuglink_size))
1395    /* XXX Should we delete the section from the bfd ?  */
1396    return NULL;
1397
1398  return sect;
1399}
1400
1401
1402/*
1403FUNCTION
1404	bfd_fill_in_gnu_debuglink_section
1405
1406SYNOPSIS
1407	bfd_boolean bfd_fill_in_gnu_debuglink_section
1408	  (bfd *abfd, struct bfd_section *sect, const char *filename);
1409
1410DESCRIPTION
1411
1412	Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1413	and fills in the contents of the section to contain a link to the
1414	specified @var{filename}.  The filename should be relative to the
1415	current directory.
1416
1417RETURNS
1418	<<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1419	and bfd_error is set.
1420*/
1421
1422bfd_boolean
1423bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1424				   struct bfd_section *sect,
1425				   const char *filename)
1426{
1427  bfd_size_type debuglink_size;
1428  unsigned long crc32;
1429  char * contents;
1430  bfd_size_type crc_offset;
1431  FILE * handle;
1432  static unsigned char buffer[8 * 1024];
1433  size_t count;
1434
1435  if (abfd == NULL || sect == NULL || filename == NULL)
1436    {
1437      bfd_set_error (bfd_error_invalid_operation);
1438      return FALSE;
1439    }
1440
1441  /* Make sure that we can read the file.
1442     XXX - Should we attempt to locate the debug info file using the same
1443     algorithm as gdb ?  At the moment, since we are creating the
1444     .gnu_debuglink section, we insist upon the user providing us with a
1445     correct-for-section-creation-time path, but this need not conform to
1446     the gdb location algorithm.  */
1447  handle = real_fopen (filename, FOPEN_RB);
1448  if (handle == NULL)
1449    {
1450      bfd_set_error (bfd_error_system_call);
1451      return FALSE;
1452    }
1453
1454  crc32 = 0;
1455  while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1456    crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1457  fclose (handle);
1458
1459  /* Strip off any path components in filename,
1460     now that we no longer need them.  */
1461  filename = lbasename (filename);
1462
1463  debuglink_size = strlen (filename) + 1;
1464  debuglink_size += 3;
1465  debuglink_size &= ~3;
1466  debuglink_size += 4;
1467
1468  contents = bfd_zmalloc (debuglink_size);
1469  if (contents == NULL)
1470    {
1471      /* XXX Should we delete the section from the bfd ?  */
1472      bfd_set_error (bfd_error_no_memory);
1473      return FALSE;
1474    }
1475
1476  strcpy (contents, filename);
1477  crc_offset = debuglink_size - 4;
1478
1479  bfd_put_32 (abfd, crc32, contents + crc_offset);
1480
1481  if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1482    {
1483      /* XXX Should we delete the section from the bfd ?  */
1484      free (contents);
1485      return FALSE;
1486    }
1487
1488  return TRUE;
1489}
1490