xref: /openbsd/gnu/usr.bin/binutils/bfd/opncls.c (revision 007c2a45)
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