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