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
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 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
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 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
128 bfd_boolean
_bfd_free_cached_info(bfd * abfd)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 /*
148 SECTION
149 Opening and closing BFDs
150
151 SUBSECTION
152 Functions for opening and closing
153 */
154
155 /*
156 FUNCTION
157 bfd_fopen
158
159 SYNOPSIS
160 bfd *bfd_fopen (const char *filename, const char *target,
161 const char *mode, int fd);
162
163 DESCRIPTION
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
180 bfd *
bfd_fopen(const char * filename,const char * target,const char * mode,int fd)181 bfd_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 /*
240 FUNCTION
241 bfd_openr
242
243 SYNOPSIS
244 bfd *bfd_openr (const char *filename, const char *target);
245
246 DESCRIPTION
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
258 bfd *
bfd_openr(const char * filename,const char * target)259 bfd_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 /*
272 FUNCTION
273 bfd_fdopenr
274
275 SYNOPSIS
276 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
277
278 DESCRIPTION
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
297 bfd *
bfd_fdopenr(const char * filename,const char * target,int fd)298 bfd_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 /*
329 FUNCTION
330 bfd_openstreamr
331
332 SYNOPSIS
333 bfd *bfd_openstreamr (const char *, const char *, void *);
334
335 DESCRIPTION
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
341 bfd *
bfd_openstreamr(const char * filename,const char * target,void * streamarg)342 bfd_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 /*
373 FUNCTION
374 bfd_openr_iovec
375
376 SYNOPSIS
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
392 DESCRIPTION
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
427 struct 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
437 static file_ptr
opncls_btell(struct bfd * abfd)438 opncls_btell (struct bfd *abfd)
439 {
440 struct opncls *vec = abfd->iostream;
441 return vec->where;
442 }
443
444 static int
opncls_bseek(struct bfd * abfd,file_ptr offset,int whence)445 opncls_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
457 static file_ptr
opncls_bread(struct bfd * abfd,void * buf,file_ptr nbytes)458 opncls_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
468 static file_ptr
opncls_bwrite(struct bfd * abfd ATTRIBUTE_UNUSED,const void * where ATTRIBUTE_UNUSED,file_ptr nbytes ATTRIBUTE_UNUSED)469 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
470 const void *where ATTRIBUTE_UNUSED,
471 file_ptr nbytes ATTRIBUTE_UNUSED)
472 {
473 return -1;
474 }
475
476 static int
opncls_bclose(struct bfd * abfd)477 opncls_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
489 static int
opncls_bflush(struct bfd * abfd ATTRIBUTE_UNUSED)490 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
491 {
492 return 0;
493 }
494
495 static int
opncls_bstat(struct bfd * abfd,struct stat * sb)496 opncls_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
507 static const struct bfd_iovec opncls_iovec = {
508 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
509 &opncls_bclose, &opncls_bflush, &opncls_bstat
510 };
511
512 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),int (* stat)(struct bfd * abfd,void * stream,struct stat * sb))513 bfd_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 /*
572 FUNCTION
573 bfd_openw
574
575 SYNOPSIS
576 bfd *bfd_openw (const char *filename, const char *target);
577
578 DESCRIPTION
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
586 bfd *
bfd_openw(const char * filename,const char * target)587 bfd_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
621 FUNCTION
622 bfd_close
623
624 SYNOPSIS
625 bfd_boolean bfd_close (bfd *abfd);
626
627 DESCRIPTION
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
639 RETURNS
640 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
641 */
642
643
644 bfd_boolean
bfd_close(bfd * abfd)645 bfd_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 /*
690 FUNCTION
691 bfd_close_all_done
692
693 SYNOPSIS
694 bfd_boolean bfd_close_all_done (bfd *);
695
696 DESCRIPTION
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
707 RETURNS
708 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
709 */
710
711 bfd_boolean
bfd_close_all_done(bfd * abfd)712 bfd_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 /*
743 FUNCTION
744 bfd_create
745
746 SYNOPSIS
747 bfd *bfd_create (const char *filename, bfd *templ);
748
749 DESCRIPTION
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
755 bfd *
bfd_create(const char * filename,bfd * templ)756 bfd_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 /*
773 FUNCTION
774 bfd_make_writable
775
776 SYNOPSIS
777 bfd_boolean bfd_make_writable (bfd *abfd);
778
779 DESCRIPTION
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
785 RETURNS
786 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
787 */
788
789 bfd_boolean
bfd_make_writable(bfd * abfd)790 bfd_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 /*
814 FUNCTION
815 bfd_make_readable
816
817 SYNOPSIS
818 bfd_boolean bfd_make_readable (bfd *abfd);
819
820 DESCRIPTION
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
827 RETURNS
828 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
829
830 bfd_boolean
bfd_make_readable(bfd * abfd)831 bfd_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 /*
874 INTERNAL_FUNCTION
875 bfd_alloc
876
877 SYNOPSIS
878 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
879
880 DESCRIPTION
881 Allocate a block of @var{wanted} bytes of memory attached to
882 <<abfd>> and return a pointer to it.
883 */
884
885 void *
bfd_alloc(bfd * abfd,bfd_size_type size)886 bfd_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 /*
903 INTERNAL_FUNCTION
904 bfd_alloc2
905
906 SYNOPSIS
907 void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
908
909 DESCRIPTION
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
914 void *
bfd_alloc2(bfd * abfd,bfd_size_type nmemb,bfd_size_type size)915 bfd_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 /*
942 INTERNAL_FUNCTION
943 bfd_zalloc
944
945 SYNOPSIS
946 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
947
948 DESCRIPTION
949 Allocate a block of @var{wanted} bytes of zeroed memory
950 attached to <<abfd>> and return a pointer to it.
951 */
952
953 void *
bfd_zalloc(bfd * abfd,bfd_size_type size)954 bfd_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 /*
965 INTERNAL_FUNCTION
966 bfd_zalloc2
967
968 SYNOPSIS
969 void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
970
971 DESCRIPTION
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
976 void *
bfd_zalloc2(bfd * abfd,bfd_size_type nmemb,bfd_size_type size)977 bfd_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
1000 void
bfd_release(bfd * abfd,void * block)1001 bfd_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 /*
1023 FUNCTION
1024 bfd_calc_gnu_debuglink_crc32
1025
1026 SYNOPSIS
1027 unsigned long bfd_calc_gnu_debuglink_crc32
1028 (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1029
1030 DESCRIPTION
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
1035 RETURNS
1036 Return the updated CRC32 value.
1037 */
1038
1039 unsigned long
bfd_calc_gnu_debuglink_crc32(unsigned long crc,const unsigned char * buf,bfd_size_type len)1040 bfd_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 /*
1109 INTERNAL_FUNCTION
1110 get_debug_link_info
1111
1112 SYNOPSIS
1113 char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1114
1115 DESCRIPTION
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
1121 static char *
get_debug_link_info(bfd * abfd,unsigned long * crc32_out)1122 get_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 /*
1157 INTERNAL_FUNCTION
1158 separate_debug_file_exists
1159
1160 SYNOPSIS
1161 bfd_boolean separate_debug_file_exists
1162 (char *name, unsigned long crc32);
1163
1164 DESCRIPTION
1165 Checks to see if @var{name} is a file and if its contents
1166 match @var{crc32}.
1167 */
1168
1169 static bfd_boolean
separate_debug_file_exists(const char * name,const unsigned long crc)1170 separate_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 /*
1193 INTERNAL_FUNCTION
1194 find_separate_debug_file
1195
1196 SYNOPSIS
1197 char *find_separate_debug_file (bfd *abfd);
1198
1199 DESCRIPTION
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
1208 static char *
find_separate_debug_file(bfd * abfd,const char * debug_file_directory)1209 find_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 /*
1311 FUNCTION
1312 bfd_follow_gnu_debuglink
1313
1314 SYNOPSIS
1315 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1316
1317 DESCRIPTION
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
1330 RETURNS
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
1336 char *
bfd_follow_gnu_debuglink(bfd * abfd,const char * dir)1337 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1338 {
1339 return find_separate_debug_file (abfd, dir);
1340 }
1341
1342 /*
1343 FUNCTION
1344 bfd_create_gnu_debuglink_section
1345
1346 SYNOPSIS
1347 struct bfd_section *bfd_create_gnu_debuglink_section
1348 (bfd *abfd, const char *filename);
1349
1350 DESCRIPTION
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
1355 RETURNS
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
1360 asection *
bfd_create_gnu_debuglink_section(bfd * abfd,const char * filename)1361 bfd_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 /*
1403 FUNCTION
1404 bfd_fill_in_gnu_debuglink_section
1405
1406 SYNOPSIS
1407 bfd_boolean bfd_fill_in_gnu_debuglink_section
1408 (bfd *abfd, struct bfd_section *sect, const char *filename);
1409
1410 DESCRIPTION
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
1417 RETURNS
1418 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1419 and bfd_error is set.
1420 */
1421
1422 bfd_boolean
bfd_fill_in_gnu_debuglink_section(bfd * abfd,struct bfd_section * sect,const char * filename)1423 bfd_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