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