Automatic date update in version.in
[binutils-gdb.git] / bfd / opncls.c
blobbc76696dfdbc497c29d44dca3383ce5f5c64f8ee
1 /* opncls.c -- open and close a BFD.
2 Copyright (C) 1990-2024 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "objalloc.h"
26 #include "libbfd.h"
27 #include "libiberty.h"
28 #include "elf-bfd.h"
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
41 SECTION
42 Opening and closing BFDs
44 SUBSECTION
45 Functions for opening and closing
48 /* Counters used to initialize the bfd identifier. */
50 static unsigned int bfd_id_counter = 0;
51 static unsigned int bfd_reserved_id_counter = 0;
54 EXTERNAL
55 .{* Set to N to open the next N BFDs using an alternate id space. *}
56 .extern unsigned int bfd_use_reserved_id;
59 unsigned int bfd_use_reserved_id = 0;
61 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
62 if we do that we can't use fcntl. */
65 INTERNAL_FUNCTION
66 _bfd_new_bfd
68 SYNOPSIS
69 bfd *_bfd_new_bfd (void);
71 DESCRIPTION
72 Return a new BFD. All BFD's are allocated through this routine.
75 bfd *
76 _bfd_new_bfd (void)
78 bfd *nbfd;
80 nbfd = (bfd *) bfd_zmalloc (sizeof (bfd));
81 if (nbfd == NULL)
82 return NULL;
84 if (!bfd_lock ())
85 return NULL;
86 if (bfd_use_reserved_id)
88 nbfd->id = --bfd_reserved_id_counter;
89 --bfd_use_reserved_id;
91 else
92 nbfd->id = bfd_id_counter++;
93 if (!bfd_unlock ())
95 free (nbfd);
96 return NULL;
99 nbfd->memory = objalloc_create ();
100 if (nbfd->memory == NULL)
102 bfd_set_error (bfd_error_no_memory);
103 free (nbfd);
104 return NULL;
107 nbfd->arch_info = &bfd_default_arch_struct;
109 if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
110 sizeof (struct section_hash_entry), 13))
112 objalloc_free ((struct objalloc *) nbfd->memory);
113 free (nbfd);
114 return NULL;
117 nbfd->archive_plugin_fd = -1;
119 return nbfd;
122 static const struct bfd_iovec opncls_iovec;
125 INTERNAL_FUNCTION
126 _bfd_new_bfd_contained_in
128 SYNOPSIS
129 bfd *_bfd_new_bfd_contained_in (bfd *);
131 DESCRIPTION
132 Allocate a new BFD as a member of archive OBFD.
135 bfd *
136 _bfd_new_bfd_contained_in (bfd *obfd)
138 bfd *nbfd;
140 /* Nested archives in bims are unsupported. */
141 if ((obfd->flags & BFD_IN_MEMORY) != 0)
143 bfd_set_error (bfd_error_malformed_archive);
144 return NULL;
146 nbfd = _bfd_new_bfd ();
147 if (nbfd == NULL)
148 return NULL;
149 nbfd->xvec = obfd->xvec;
150 nbfd->iovec = obfd->iovec;
151 if (obfd->iovec == &opncls_iovec)
152 nbfd->iostream = obfd->iostream;
153 nbfd->my_archive = obfd;
154 nbfd->direction = read_direction;
155 nbfd->target_defaulted = obfd->target_defaulted;
156 nbfd->lto_output = obfd->lto_output;
157 nbfd->no_export = obfd->no_export;
158 return nbfd;
161 /* Delete a BFD. */
163 static void
164 _bfd_delete_bfd (bfd *abfd)
166 #ifdef USE_MMAP
167 if (abfd->xvec
168 && abfd->xvec->flavour == bfd_target_elf_flavour)
170 asection *sec;
171 for (sec = abfd->sections; sec != NULL; sec = sec->next)
172 if (sec->mmapped_p)
173 munmap (elf_section_data (sec)->contents_addr,
174 elf_section_data (sec)->contents_size);
176 #endif
178 /* Give the target _bfd_free_cached_info a chance to free memory. */
179 if (abfd->memory && abfd->xvec)
180 bfd_free_cached_info (abfd);
182 /* The target _bfd_free_cached_info may not have done anything.. */
183 if (abfd->memory)
185 bfd_hash_table_free (&abfd->section_htab);
186 objalloc_free ((struct objalloc *) abfd->memory);
188 else
189 free ((char *) bfd_get_filename (abfd));
191 #ifdef USE_MMAP
192 struct bfd_mmapped *mmapped, *next;
193 for (mmapped = abfd->mmapped; mmapped != NULL; mmapped = next)
195 struct bfd_mmapped_entry *entries = mmapped->entries;
196 next = mmapped->next;
197 for (unsigned int i = 0; i < mmapped->next_entry; i++)
198 munmap (entries[i].addr, entries[i].size);
199 munmap (mmapped, _bfd_pagesize);
201 #endif
203 free (abfd->arelt_data);
204 free (abfd);
208 INTERNAL_FUNCTION
209 _bfd_free_cached_info
211 SYNOPSIS
212 bool _bfd_free_cached_info (bfd *);
214 DESCRIPTION
215 Free objalloc memory.
218 bool
219 _bfd_free_cached_info (bfd *abfd)
221 if (abfd->memory)
223 const char *filename = bfd_get_filename (abfd);
224 if (filename)
226 /* We can't afford to lose the bfd filename when freeing
227 abfd->memory, because that would kill the cache.c scheme
228 of closing and reopening files in order to limit the
229 number of open files. To reopen, you need the filename.
230 And indeed _bfd_compute_and_write_armap calls
231 _bfd_free_cached_info to free up space used by symbols
232 and by check_format_matches. Which we want to continue
233 doing to handle very large archives. Later the archive
234 elements are copied, which might require reopening files.
235 We also want to keep using objalloc memory for the
236 filename since that allows the name to be updated
237 without either leaking memory or implementing some sort
238 of reference counted string for copies of the filename. */
239 size_t len = strlen (filename) + 1;
240 char *copy = bfd_malloc (len);
241 if (copy == NULL)
242 return false;
243 memcpy (copy, filename, len);
244 abfd->filename = copy;
246 bfd_hash_table_free (&abfd->section_htab);
247 objalloc_free ((struct objalloc *) abfd->memory);
249 abfd->sections = NULL;
250 abfd->section_last = NULL;
251 abfd->outsymbols = NULL;
252 abfd->tdata.any = NULL;
253 abfd->usrdata = NULL;
254 abfd->memory = NULL;
257 return true;
261 FUNCTION
262 bfd_fopen
264 SYNOPSIS
265 bfd *bfd_fopen (const char *filename, const char *target,
266 const char *mode, int fd);
268 DESCRIPTION
269 Open the file @var{filename} with the target @var{target}.
270 Return a pointer to the created BFD. If @var{fd} is not -1,
271 then <<fdopen>> is used to open the file; otherwise, <<fopen>>
272 is used. @var{mode} is passed directly to <<fopen>> or
273 <<fdopen>>.
275 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
276 that function.
278 The new BFD is marked as cacheable iff @var{fd} is -1.
280 If <<NULL>> is returned then an error has occured. Possible errors
281 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
282 <<system_call>> error.
284 On error, @var{fd} is always closed.
286 A copy of the @var{filename} argument is stored in the newly created
287 BFD. It can be accessed via the bfd_get_filename() macro.
290 bfd *
291 bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
293 bfd *nbfd;
294 const bfd_target *target_vec;
296 nbfd = _bfd_new_bfd ();
297 if (nbfd == NULL)
299 if (fd != -1)
300 close (fd);
301 return NULL;
304 target_vec = bfd_find_target (target, nbfd);
305 if (target_vec == NULL)
307 if (fd != -1)
308 close (fd);
309 _bfd_delete_bfd (nbfd);
310 return NULL;
313 #ifdef HAVE_FDOPEN
314 if (fd != -1)
315 nbfd->iostream = fdopen (fd, mode);
316 else
317 #endif
318 nbfd->iostream = _bfd_real_fopen (filename, mode);
319 if (nbfd->iostream == NULL)
321 bfd_set_error (bfd_error_system_call);
322 if (fd != -1)
323 close (fd);
324 _bfd_delete_bfd (nbfd);
325 return NULL;
328 /* OK, put everything where it belongs. */
330 /* PR 11983: Do not cache the original filename, but
331 rather make a copy - the original might go away. */
332 if (!bfd_set_filename (nbfd, filename))
334 fclose (nbfd->iostream);
335 _bfd_delete_bfd (nbfd);
336 return NULL;
339 /* Figure out whether the user is opening the file for reading,
340 writing, or both, by looking at the MODE argument. */
341 if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
342 && mode[1] == '+')
343 nbfd->direction = both_direction;
344 else if (mode[0] == 'r')
345 nbfd->direction = read_direction;
346 else
347 nbfd->direction = write_direction;
349 if (!bfd_cache_init (nbfd))
351 fclose (nbfd->iostream);
352 _bfd_delete_bfd (nbfd);
353 return NULL;
355 nbfd->opened_once = true;
357 /* If we opened the file by name, mark it cacheable; we can close it
358 and reopen it later. However, if a file descriptor was provided,
359 then it may have been opened with special flags that make it
360 unsafe to close and reopen the file. */
361 if (fd == -1)
362 (void) bfd_set_cacheable (nbfd, true);
364 return nbfd;
368 FUNCTION
369 bfd_openr
371 SYNOPSIS
372 bfd *bfd_openr (const char *filename, const char *target);
374 DESCRIPTION
375 Open the file @var{filename} (using <<fopen>>) with the target
376 @var{target}. Return a pointer to the created BFD.
378 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
379 that function.
381 If <<NULL>> is returned then an error has occured. Possible errors
382 are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
383 <<system_call>> error.
385 A copy of the @var{filename} argument is stored in the newly created
386 BFD. It can be accessed via the bfd_get_filename() macro.
389 bfd *
390 bfd_openr (const char *filename, const char *target)
392 return bfd_fopen (filename, target, FOPEN_RB, -1);
395 /* Don't try to `optimize' this function:
397 o - We lock using stack space so that interrupting the locking
398 won't cause a storage leak.
399 o - We open the file stream last, since we don't want to have to
400 close it if anything goes wrong. Closing the stream means closing
401 the file descriptor too, even though we didn't open it. */
403 FUNCTION
404 bfd_fdopenr
406 SYNOPSIS
407 bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
409 DESCRIPTION
410 <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
411 <<fopen>>. It opens a BFD on a file already described by the
412 @var{fd} supplied.
414 When the file is later <<bfd_close>>d, the file descriptor will
415 be closed. If the caller desires that this file descriptor be
416 cached by BFD (opened as needed, closed as needed to free
417 descriptors for other opens), with the supplied @var{fd} used as
418 an initial file descriptor (but subject to closure at any time),
419 call bfd_set_cacheable(bfd, 1) on the returned BFD. The default
420 is to assume no caching; the file descriptor will remain open
421 until <<bfd_close>>, and will not be affected by BFD operations
422 on other files.
424 Possible errors are <<bfd_error_no_memory>>,
425 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
427 On error, @var{fd} is closed.
429 A copy of the @var{filename} argument is stored in the newly created
430 BFD. It can be accessed via the bfd_get_filename() macro.
433 bfd *
434 bfd_fdopenr (const char *filename, const char *target, int fd)
436 const char *mode;
437 #if defined(HAVE_FCNTL) && defined(F_GETFL)
438 int fdflags;
439 #endif
441 #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
442 mode = FOPEN_RUB; /* Assume full access. */
443 #else
444 fdflags = fcntl (fd, F_GETFL, NULL);
445 if (fdflags == -1)
447 int save = errno;
449 close (fd);
450 errno = save;
451 bfd_set_error (bfd_error_system_call);
452 return NULL;
455 /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */
456 switch (fdflags & (O_ACCMODE))
458 case O_RDONLY: mode = FOPEN_RB; break;
459 case O_WRONLY: mode = FOPEN_RUB; break;
460 case O_RDWR: mode = FOPEN_RUB; break;
461 default: abort ();
463 #endif
465 return bfd_fopen (filename, target, mode, fd);
469 FUNCTION
470 bfd_fdopenw
472 SYNOPSIS
473 bfd *bfd_fdopenw (const char *filename, const char *target, int fd);
475 DESCRIPTION
476 <<bfd_fdopenw>> is exactly like <<bfd_fdopenr>> with the exception that
477 the resulting BFD is suitable for output.
480 bfd *
481 bfd_fdopenw (const char *filename, const char *target, int fd)
483 bfd *out = bfd_fdopenr (filename, target, fd);
485 if (out != NULL)
487 if (!bfd_write_p (out))
489 close (fd);
490 _bfd_delete_bfd (out);
491 out = NULL;
492 bfd_set_error (bfd_error_invalid_operation);
494 else
495 out->direction = write_direction;
498 return out;
502 FUNCTION
503 bfd_openstreamr
505 SYNOPSIS
506 bfd *bfd_openstreamr (const char * filename, const char * target,
507 void * stream);
509 DESCRIPTION
510 Open a BFD for read access on an existing stdio stream. When
511 the BFD is passed to <<bfd_close>>, the stream will be closed.
513 A copy of the @var{filename} argument is stored in the newly created
514 BFD. It can be accessed via the bfd_get_filename() macro.
517 bfd *
518 bfd_openstreamr (const char *filename, const char *target, void *streamarg)
520 FILE *stream = (FILE *) streamarg;
521 bfd *nbfd;
522 const bfd_target *target_vec;
524 nbfd = _bfd_new_bfd ();
525 if (nbfd == NULL)
526 return NULL;
528 target_vec = bfd_find_target (target, nbfd);
529 if (target_vec == NULL)
531 _bfd_delete_bfd (nbfd);
532 return NULL;
535 nbfd->iostream = stream;
536 /* PR 11983: Do not cache the original filename, but
537 rather make a copy - the original might go away. */
538 if (!bfd_set_filename (nbfd, filename))
540 _bfd_delete_bfd (nbfd);
541 return NULL;
543 nbfd->direction = read_direction;
545 if (! bfd_cache_init (nbfd))
547 _bfd_delete_bfd (nbfd);
548 return NULL;
551 return nbfd;
555 FUNCTION
556 bfd_openr_iovec
558 SYNOPSIS
559 bfd *bfd_openr_iovec (const char *filename, const char *target,
560 void *(*open_func) (struct bfd *nbfd,
561 void *open_closure),
562 void *open_closure,
563 file_ptr (*pread_func) (struct bfd *nbfd,
564 void *stream,
565 void *buf,
566 file_ptr nbytes,
567 file_ptr offset),
568 int (*close_func) (struct bfd *nbfd,
569 void *stream),
570 int (*stat_func) (struct bfd *abfd,
571 void *stream,
572 struct stat *sb));
574 DESCRIPTION
575 Create and return a BFD backed by a read-only @var{stream}.
576 The @var{stream} is created using @var{open_func}, accessed using
577 @var{pread_func} and destroyed using @var{close_func}.
579 Calls <<bfd_find_target>>, so @var{target} is interpreted as by
580 that function.
582 Calls @var{open_func} (which can call <<bfd_zalloc>> and
583 <<bfd_get_filename>>) to obtain the read-only stream backing
584 the BFD. @var{open_func} either succeeds returning the
585 non-<<NULL>> @var{stream}, or fails returning <<NULL>>
586 (setting <<bfd_error>>).
588 Calls @var{pread_func} to request @var{nbytes} of data from
589 @var{stream} starting at @var{offset} (e.g., via a call to
590 <<bfd_read>>). @var{pread_func} either succeeds returning the
591 number of bytes read (which can be less than @var{nbytes} when
592 end-of-file), or fails returning -1 (setting <<bfd_error>>).
594 Calls @var{close_func} when the BFD is later closed using
595 <<bfd_close>>. @var{close_func} either succeeds returning 0, or
596 fails returning -1 (setting <<bfd_error>>).
598 Calls @var{stat_func} to fill in a stat structure for bfd_stat,
599 bfd_get_size, and bfd_get_mtime calls. @var{stat_func} returns 0
600 on success, or returns -1 on failure (setting <<bfd_error>>).
602 If <<bfd_openr_iovec>> returns <<NULL>> then an error has
603 occurred. Possible errors are <<bfd_error_no_memory>>,
604 <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
606 A copy of the @var{filename} argument is stored in the newly created
607 BFD. It can be accessed via the bfd_get_filename() macro.
610 struct opncls
612 void *stream;
613 file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
614 file_ptr nbytes, file_ptr offset);
615 int (*close) (struct bfd *abfd, void *stream);
616 int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
617 file_ptr where;
620 static file_ptr
621 opncls_btell (struct bfd *abfd)
623 struct opncls *vec = (struct opncls *) abfd->iostream;
624 return vec->where;
627 static int
628 opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
630 struct opncls *vec = (struct opncls *) abfd->iostream;
631 switch (whence)
633 case SEEK_SET: vec->where = offset; break;
634 case SEEK_CUR: vec->where += offset; break;
635 case SEEK_END: return -1;
637 return 0;
640 static file_ptr
641 opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
643 struct opncls *vec = (struct opncls *) abfd->iostream;
644 file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
646 if (nread < 0)
647 return nread;
648 vec->where += nread;
649 return nread;
652 static file_ptr
653 opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
654 const void *where ATTRIBUTE_UNUSED,
655 file_ptr nbytes ATTRIBUTE_UNUSED)
657 return -1;
660 static int
661 opncls_bclose (struct bfd *abfd)
663 struct opncls *vec = (struct opncls *) abfd->iostream;
664 /* Since the VEC's memory is bound to the bfd deleting the bfd will
665 free it. */
666 int status = 0;
668 if (vec->close != NULL)
669 status = (vec->close) (abfd, vec->stream);
670 abfd->iostream = NULL;
671 return status;
674 static int
675 opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
677 return 0;
680 static int
681 opncls_bstat (struct bfd *abfd, struct stat *sb)
683 struct opncls *vec = (struct opncls *) abfd->iostream;
685 memset (sb, 0, sizeof (*sb));
686 if (vec->stat == NULL)
687 return 0;
689 return (vec->stat) (abfd, vec->stream, sb);
692 static void *
693 opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
694 void *addr ATTRIBUTE_UNUSED,
695 size_t len ATTRIBUTE_UNUSED,
696 int prot ATTRIBUTE_UNUSED,
697 int flags ATTRIBUTE_UNUSED,
698 file_ptr offset ATTRIBUTE_UNUSED,
699 void **map_addr ATTRIBUTE_UNUSED,
700 size_t *map_len ATTRIBUTE_UNUSED)
702 return MAP_FAILED;
705 static const struct bfd_iovec opncls_iovec =
707 &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
708 &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
711 bfd *
712 bfd_openr_iovec (const char *filename, const char *target,
713 void *(*open_p) (struct bfd *, void *),
714 void *open_closure,
715 file_ptr (*pread_p) (struct bfd *, void *, void *,
716 file_ptr, file_ptr),
717 int (*close_p) (struct bfd *, void *),
718 int (*stat_p) (struct bfd *, void *, struct stat *))
720 bfd *nbfd;
721 const bfd_target *target_vec;
722 struct opncls *vec;
723 void *stream;
725 nbfd = _bfd_new_bfd ();
726 if (nbfd == NULL)
727 return NULL;
729 target_vec = bfd_find_target (target, nbfd);
730 if (target_vec == NULL)
732 _bfd_delete_bfd (nbfd);
733 return NULL;
736 /* PR 11983: Do not cache the original filename, but
737 rather make a copy - the original might go away. */
738 if (!bfd_set_filename (nbfd, filename))
740 _bfd_delete_bfd (nbfd);
741 return NULL;
743 nbfd->direction = read_direction;
745 /* `open_p (...)' would get expanded by an the open(2) syscall macro. */
746 stream = (*open_p) (nbfd, open_closure);
747 if (stream == NULL)
749 _bfd_delete_bfd (nbfd);
750 return NULL;
753 vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));
754 vec->stream = stream;
755 vec->pread = pread_p;
756 vec->close = close_p;
757 vec->stat = stat_p;
759 nbfd->iovec = &opncls_iovec;
760 nbfd->iostream = vec;
762 return nbfd;
765 /* bfd_openw -- open for writing.
766 Returns a pointer to a freshly-allocated BFD on success, or NULL.
768 See comment by bfd_fdopenr before you try to modify this function. */
771 FUNCTION
772 bfd_openw
774 SYNOPSIS
775 bfd *bfd_openw (const char *filename, const char *target);
777 DESCRIPTION
778 Create a BFD, associated with file @var{filename}, using the
779 file format @var{target}, and return a pointer to it.
781 Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
782 <<bfd_error_invalid_target>>.
784 A copy of the @var{filename} argument is stored in the newly created
785 BFD. It can be accessed via the bfd_get_filename() macro.
788 bfd *
789 bfd_openw (const char *filename, const char *target)
791 bfd *nbfd;
792 const bfd_target *target_vec;
794 /* nbfd has to point to head of malloc'ed block so that bfd_close may
795 reclaim it correctly. */
796 nbfd = _bfd_new_bfd ();
797 if (nbfd == NULL)
798 return NULL;
800 target_vec = bfd_find_target (target, nbfd);
801 if (target_vec == NULL)
803 _bfd_delete_bfd (nbfd);
804 return NULL;
807 /* PR 11983: Do not cache the original filename, but
808 rather make a copy - the original might go away. */
809 if (!bfd_set_filename (nbfd, filename))
811 _bfd_delete_bfd (nbfd);
812 return NULL;
814 nbfd->direction = write_direction;
816 if (bfd_open_file (nbfd) == NULL)
818 /* File not writeable, etc. */
819 bfd_set_error (bfd_error_system_call);
820 _bfd_delete_bfd (nbfd);
821 return NULL;
824 return nbfd;
828 FUNCTION
829 bfd_elf_bfd_from_remote_memory
831 SYNOPSIS
832 bfd *bfd_elf_bfd_from_remote_memory
833 (bfd *templ, bfd_vma ehdr_vma, bfd_size_type size, bfd_vma *loadbasep,
834 int (*target_read_memory)
835 (bfd_vma vma, bfd_byte *myaddr, bfd_size_type len));
837 DESCRIPTION
838 Create a new BFD as if by bfd_openr. Rather than opening a
839 file, reconstruct an ELF file by reading the segments out of
840 remote memory based on the ELF file header at EHDR_VMA and the
841 ELF program headers it points to. If non-zero, SIZE is the
842 known extent of the object. If not null, *LOADBASEP is filled
843 in with the difference between the VMAs from which the
844 segments were read, and the VMAs the file headers (and hence
845 BFD's idea of each section's VMA) put them at.
847 The function TARGET_READ_MEMORY is called to copy LEN bytes
848 from the remote memory at target address VMA into the local
849 buffer at MYADDR; it should return zero on success or an
850 errno code on failure. TEMPL must be a BFD for an ELF
851 target with the word size and byte order found in the remote
852 memory.
855 bfd *
856 bfd_elf_bfd_from_remote_memory
857 (bfd *templ,
858 bfd_vma ehdr_vma,
859 bfd_size_type size,
860 bfd_vma *loadbasep,
861 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
863 if (bfd_get_flavour (templ) != bfd_target_elf_flavour)
865 bfd_set_error (bfd_error_invalid_operation);
866 return NULL;
868 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
869 (templ, ehdr_vma, size, loadbasep, target_read_memory);
872 static inline void
873 _maybe_make_executable (bfd * abfd)
875 /* If the file was open for writing and is now executable,
876 make it so. */
877 if (abfd->direction == write_direction
878 && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)
880 struct stat buf;
882 if (stat (bfd_get_filename (abfd), &buf) == 0
883 /* Do not attempt to change non-regular files. This is
884 here especially for configure scripts and kernel builds
885 which run tests with "ld [...] -o /dev/null". */
886 && S_ISREG(buf.st_mode))
888 unsigned int mask = umask (0);
890 umask (mask);
891 chmod (bfd_get_filename (abfd),
892 (0777
893 & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
899 FUNCTION
900 bfd_close
902 SYNOPSIS
903 bool bfd_close (bfd *abfd);
905 DESCRIPTION
906 Close a BFD. If the BFD was open for writing, then pending
907 operations are completed and the file written out and closed.
908 If the created file is executable, then <<chmod>> is called
909 to mark it as such.
911 All memory attached to the BFD is released.
913 The file descriptor associated with the BFD is closed (even
914 if it was passed in to BFD by <<bfd_fdopenr>>).
916 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
919 bool
920 bfd_close (bfd *abfd)
922 bool ret = (!bfd_write_p (abfd)
923 || BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)));
925 return bfd_close_all_done (abfd) && ret;
929 FUNCTION
930 bfd_close_all_done
932 SYNOPSIS
933 bool bfd_close_all_done (bfd *);
935 DESCRIPTION
936 Close a BFD. Differs from <<bfd_close>> since it does not
937 complete any pending operations. This routine would be used
938 if the application had just used BFD for swapping and didn't
939 want to use any of the writing code.
941 If the created file is executable, then <<chmod>> is called
942 to mark it as such.
944 All memory attached to the BFD is released.
946 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
949 bool
950 bfd_close_all_done (bfd *abfd)
952 bool ret = BFD_SEND (abfd, _close_and_cleanup, (abfd));
954 if (abfd->iovec != NULL)
955 ret &= abfd->iovec->bclose (abfd) == 0;
957 if (ret)
958 _maybe_make_executable (abfd);
960 _bfd_delete_bfd (abfd);
961 _bfd_clear_error_data ();
963 return ret;
967 FUNCTION
968 bfd_create
970 SYNOPSIS
971 bfd *bfd_create (const char *filename, bfd *templ);
973 DESCRIPTION
974 Create a new BFD in the manner of <<bfd_openw>>, but without
975 opening a file. The new BFD takes the target from the target
976 used by @var{templ}. The format is always set to <<bfd_object>>.
978 A copy of the @var{filename} argument is stored in the newly created
979 BFD. It can be accessed via the bfd_get_filename() macro.
982 bfd *
983 bfd_create (const char *filename, bfd *templ)
985 bfd *nbfd;
987 nbfd = _bfd_new_bfd ();
988 if (nbfd == NULL)
989 return NULL;
990 /* PR 11983: Do not cache the original filename, but
991 rather make a copy - the original might go away. */
992 if (!bfd_set_filename (nbfd, filename))
994 _bfd_delete_bfd (nbfd);
995 return NULL;
997 if (templ)
998 nbfd->xvec = templ->xvec;
999 nbfd->direction = no_direction;
1000 bfd_set_format (nbfd, bfd_object);
1002 return nbfd;
1006 FUNCTION
1007 bfd_make_writable
1009 SYNOPSIS
1010 bool bfd_make_writable (bfd *abfd);
1012 DESCRIPTION
1013 Takes a BFD as created by <<bfd_create>> and converts it
1014 into one like as returned by <<bfd_openw>>. It does this
1015 by converting the BFD to BFD_IN_MEMORY. It's assumed that
1016 you will call <<bfd_make_readable>> on this bfd later.
1018 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
1021 bool
1022 bfd_make_writable (bfd *abfd)
1024 struct bfd_in_memory *bim;
1026 if (abfd->direction != no_direction)
1028 bfd_set_error (bfd_error_invalid_operation);
1029 return false;
1032 bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
1033 if (bim == NULL)
1034 return false; /* bfd_error already set. */
1035 abfd->iostream = bim;
1036 /* bfd_write will grow these as needed. */
1037 bim->size = 0;
1038 bim->buffer = 0;
1040 abfd->flags |= BFD_IN_MEMORY;
1041 abfd->iovec = &_bfd_memory_iovec;
1042 abfd->origin = 0;
1043 abfd->direction = write_direction;
1044 abfd->where = 0;
1046 return true;
1050 FUNCTION
1051 bfd_make_readable
1053 SYNOPSIS
1054 bool bfd_make_readable (bfd *abfd);
1056 DESCRIPTION
1057 Takes a BFD as created by <<bfd_create>> and
1058 <<bfd_make_writable>> and converts it into one like as
1059 returned by <<bfd_openr>>. It does this by writing the
1060 contents out to the memory buffer, then reversing the
1061 direction.
1063 <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */
1065 bool
1066 bfd_make_readable (bfd *abfd)
1068 if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
1070 bfd_set_error (bfd_error_invalid_operation);
1071 return false;
1074 if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
1075 return false;
1077 if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
1078 return false;
1080 abfd->arch_info = &bfd_default_arch_struct;
1082 abfd->where = 0;
1083 abfd->format = bfd_unknown;
1084 abfd->my_archive = NULL;
1085 abfd->origin = 0;
1086 abfd->opened_once = false;
1087 abfd->output_has_begun = false;
1088 abfd->section_count = 0;
1089 abfd->usrdata = NULL;
1090 abfd->cacheable = false;
1091 abfd->mtime_set = false;
1093 abfd->target_defaulted = true;
1094 abfd->direction = read_direction;
1095 abfd->sections = 0;
1096 abfd->symcount = 0;
1097 abfd->outsymbols = 0;
1098 abfd->tdata.any = 0;
1099 abfd->size = 0;
1101 bfd_section_list_clear (abfd);
1102 bfd_check_format (abfd, bfd_object);
1104 return true;
1108 GNU Extension: separate debug-info files
1110 The idea here is that a special section called .gnu_debuglink might be
1111 embedded in a binary file, which indicates that some *other* file
1112 contains the real debugging information. This special section contains a
1113 filename and CRC32 checksum, which we read and resolve to another file,
1114 if it exists.
1116 This facilitates "optional" provision of debugging information, without
1117 having to provide two complete copies of every binary object (with and
1118 without debug symbols). */
1120 #define GNU_DEBUGLINK ".gnu_debuglink"
1121 #define GNU_DEBUGALTLINK ".gnu_debugaltlink"
1124 FUNCTION
1125 bfd_calc_gnu_debuglink_crc32
1127 SYNOPSIS
1128 uint32_t bfd_calc_gnu_debuglink_crc32
1129 (uint32_t crc, const bfd_byte *buf, bfd_size_type len);
1131 DESCRIPTION
1132 Computes a CRC value as used in the .gnu_debuglink section.
1133 Advances the previously computed @var{crc} value by computing
1134 and adding in the crc32 for @var{len} bytes of @var{buf}.
1136 Return the updated CRC32 value.
1139 uint32_t
1140 bfd_calc_gnu_debuglink_crc32 (uint32_t crc,
1141 const bfd_byte *buf,
1142 bfd_size_type len)
1144 static const uint32_t crc32_table[256] =
1146 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1147 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1148 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1149 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1150 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1151 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1152 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1153 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1154 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1155 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1156 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1157 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1158 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1159 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1160 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1161 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1162 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1163 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1164 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1165 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1166 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1167 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1168 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1169 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1170 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1171 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1172 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1173 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1174 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1175 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1176 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1177 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1178 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1179 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1180 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1181 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1182 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1183 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1184 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1185 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1186 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1187 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1188 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1189 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1190 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1191 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1192 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1193 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1194 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1195 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1196 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1197 0x2d02ef8d
1199 const bfd_byte *end;
1201 crc = ~crc & 0xffffffff;
1202 for (end = buf + len; buf < end; ++ buf)
1203 crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1204 return ~crc & 0xffffffff;
1208 /* Extracts the filename and CRC32 value for any separate debug
1209 information file associated with @var{abfd}.
1211 The @var{crc32_out} parameter is an untyped pointer because
1212 this routine is used as a @code{get_func_type} function, but it
1213 is expected to be a uint32_t pointer.
1215 Returns the filename of the associated debug information file,
1216 or NULL if there is no such file. If the filename was found
1217 then the contents of @var{crc32_out} are updated to hold the
1218 corresponding CRC32 value for the file.
1220 The returned filename is allocated with @code{malloc}; freeing
1221 it is the responsibility of the caller. */
1223 static char *
1224 bfd_get_debug_link_info_1 (bfd *abfd, void *crc32_out)
1226 asection *sect;
1227 uint32_t *crc32 = crc32_out;
1228 bfd_byte *contents;
1229 unsigned int crc_offset;
1230 char *name;
1231 bfd_size_type size;
1233 BFD_ASSERT (abfd);
1234 BFD_ASSERT (crc32_out);
1236 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1238 if (sect == NULL || (sect->flags & SEC_HAS_CONTENTS) == 0)
1239 return NULL;
1241 size = bfd_section_size (sect);
1243 /* PR 22794: Make sure that the section has a reasonable size. */
1244 if (size < 8)
1245 return NULL;
1247 if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1248 return NULL;
1250 /* CRC value is stored after the filename, aligned up to 4 bytes. */
1251 name = (char *) contents;
1252 /* PR 17597: Avoid reading off the end of the buffer. */
1253 crc_offset = strnlen (name, size) + 1;
1254 crc_offset = (crc_offset + 3) & ~3;
1255 if (crc_offset + 4 > size)
1257 free (name);
1258 return NULL;
1261 *crc32 = bfd_get_32 (abfd, contents + crc_offset);
1262 return name;
1267 FUNCTION
1268 bfd_get_debug_link_info
1270 SYNOPSIS
1271 char *bfd_get_debug_link_info (bfd *abfd, uint32_t *crc32_out);
1273 DESCRIPTION
1274 Extracts the filename and CRC32 value for any separate debug
1275 information file associated with @var{abfd}.
1277 Returns the filename of the associated debug information file,
1278 or NULL if there is no such file. If the filename was found
1279 then the contents of @var{crc32_out} are updated to hold the
1280 corresponding CRC32 value for the file.
1282 The returned filename is allocated with @code{malloc}; freeing
1283 it is the responsibility of the caller.
1286 char *
1287 bfd_get_debug_link_info (bfd *abfd, uint32_t *crc32_out)
1289 return bfd_get_debug_link_info_1 (abfd, crc32_out);
1293 FUNCTION
1294 bfd_get_alt_debug_link_info
1296 SYNOPSIS
1297 char *bfd_get_alt_debug_link_info (bfd * abfd,
1298 bfd_size_type *buildid_len,
1299 bfd_byte **buildid_out);
1301 DESCRIPTION
1302 Fetch the filename and BuildID value for any alternate debuginfo
1303 associated with @var{abfd}. Return NULL if no such info found,
1304 otherwise return filename and update @var{buildid_len} and
1305 @var{buildid_out}. The returned filename and build_id are
1306 allocated with @code{malloc}; freeing them is the responsibility
1307 of the caller.
1310 char *
1311 bfd_get_alt_debug_link_info (bfd * abfd, bfd_size_type *buildid_len,
1312 bfd_byte **buildid_out)
1314 asection *sect;
1315 bfd_byte *contents;
1316 unsigned int buildid_offset;
1317 char *name;
1318 bfd_size_type size;
1320 BFD_ASSERT (abfd);
1321 BFD_ASSERT (buildid_len);
1322 BFD_ASSERT (buildid_out);
1324 sect = bfd_get_section_by_name (abfd, GNU_DEBUGALTLINK);
1326 if (sect == NULL || (sect->flags & SEC_HAS_CONTENTS) == 0)
1327 return NULL;
1329 size = bfd_section_size (sect);
1330 if (size < 8)
1331 return NULL;
1333 if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1334 return NULL;
1336 /* BuildID value is stored after the filename. */
1337 name = (char *) contents;
1338 buildid_offset = strnlen (name, size) + 1;
1339 if (buildid_offset >= bfd_section_size (sect))
1340 return NULL;
1342 *buildid_len = size - buildid_offset;
1343 *buildid_out = bfd_malloc (*buildid_len);
1344 memcpy (*buildid_out, contents + buildid_offset, *buildid_len);
1346 return name;
1349 /* Checks to see if @var{name} is a file and if its contents match
1350 @var{crc32}, which is a pointer to a @code{uint32_t}
1351 containing a CRC32.
1353 The @var{crc32_p} parameter is an untyped pointer because this
1354 routine is used as a @code{check_func_type} function. */
1356 static bool
1357 separate_debug_file_exists (const char *name, void *crc32_p)
1359 unsigned char buffer[8 * 1024];
1360 uint32_t file_crc = 0;
1361 FILE *f;
1362 bfd_size_type count;
1363 uint32_t crc;
1365 BFD_ASSERT (name);
1366 BFD_ASSERT (crc32_p);
1368 crc = *(uint32_t *) crc32_p;
1370 f = _bfd_real_fopen (name, FOPEN_RB);
1371 if (f == NULL)
1372 return false;
1374 while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1375 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1377 fclose (f);
1379 return crc == file_crc;
1382 /* Checks to see if @var{name} is a file. */
1384 static bool
1385 separate_alt_debug_file_exists (const char *name, void *unused ATTRIBUTE_UNUSED)
1387 FILE *f;
1389 BFD_ASSERT (name);
1391 f = _bfd_real_fopen (name, FOPEN_RB);
1392 if (f == NULL)
1393 return false;
1395 fclose (f);
1397 return true;
1400 /* Searches for a debug information file corresponding to @var{abfd}.
1402 The name of the separate debug info file is returned by the
1403 @var{get} function. This function scans various fixed locations
1404 in the filesystem, including the file tree rooted at @var{dir}.
1405 If the @var{include_dirs} parameter is true then the directory
1406 components of @var{abfd}'s filename will be included in the
1407 searched locations.
1409 @var{data} is passed unmodified to the @var{get} and @var{check}
1410 functions. It is generally used to implement build-id-like
1411 matching in the callback functions.
1413 Returns the filename of the first file to be found which
1414 receives a TRUE result from the @var{check} function.
1415 Returns NULL if no valid file could be found. */
1417 typedef char * (*get_func_type) (bfd *, void *);
1418 typedef bool (*check_func_type) (const char *, void *);
1420 static char *
1421 find_separate_debug_file (bfd *abfd,
1422 const char *debug_file_directory,
1423 bool include_dirs,
1424 get_func_type get_func,
1425 check_func_type check_func,
1426 void *func_data)
1428 char *base;
1429 char *dir;
1430 char *debugfile;
1431 char *canon_dir;
1432 size_t dirlen;
1433 size_t canon_dirlen;
1435 BFD_ASSERT (abfd);
1436 if (debug_file_directory == NULL)
1437 debug_file_directory = ".";
1439 /* BFD may have been opened from a stream. */
1440 if (bfd_get_filename (abfd) == NULL)
1442 bfd_set_error (bfd_error_invalid_operation);
1443 return NULL;
1446 base = get_func (abfd, func_data);
1448 if (base == NULL)
1449 return NULL;
1451 if (base[0] == '\0')
1453 free (base);
1454 bfd_set_error (bfd_error_no_debug_section);
1455 return NULL;
1458 if (include_dirs)
1460 const char *fname = bfd_get_filename (abfd);
1461 for (dirlen = strlen (fname); dirlen > 0; dirlen--)
1462 if (IS_DIR_SEPARATOR (fname[dirlen - 1]))
1463 break;
1465 dir = (char *) bfd_malloc (dirlen + 1);
1466 if (dir == NULL)
1468 free (base);
1469 return NULL;
1471 memcpy (dir, fname, dirlen);
1472 dir[dirlen] = '\0';
1474 else
1476 dir = (char *) bfd_malloc (1);
1477 * dir = 0;
1478 dirlen = 0;
1481 /* Compute the canonical name of the bfd object with all symbolic links
1482 resolved, for use in the global debugfile directory. */
1483 canon_dir = lrealpath (bfd_get_filename (abfd));
1484 for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1485 if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1486 break;
1487 canon_dir[canon_dirlen] = '\0';
1489 #ifndef EXTRA_DEBUG_ROOT1
1490 #define EXTRA_DEBUG_ROOT1 "/usr/lib/debug"
1491 #endif
1492 #ifndef EXTRA_DEBUG_ROOT2
1493 #define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr"
1494 #endif
1496 debugfile = (char *)
1497 bfd_malloc (strlen (debug_file_directory) + 1
1498 + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1499 + strlen (".debug/")
1500 #ifdef EXTRA_DEBUG_ROOT1
1501 + strlen (EXTRA_DEBUG_ROOT1)
1502 #endif
1503 #ifdef EXTRA_DEBUG_ROOT2
1504 + strlen (EXTRA_DEBUG_ROOT2)
1505 #endif
1506 + strlen (base)
1507 + 1);
1508 if (debugfile == NULL)
1509 goto found; /* Actually this returns NULL. */
1511 /* First try in the same directory as the original file.
1513 FIXME: Strictly speaking if we are using the build-id method,
1514 (ie include_dirs == FALSE) then we should only check absolute
1515 paths, not relative ones like this one (and the next one).
1516 The check is left in however as this allows the binutils
1517 testsuite to exercise this feature without having to install
1518 a file into the root filesystem. (See binutils/testsuite/
1519 binutils-all/objdump.exp for the test). */
1520 sprintf (debugfile, "%s%s", dir, base);
1521 if (check_func (debugfile, func_data))
1522 goto found;
1524 /* Then try in a subdirectory called .debug. */
1525 sprintf (debugfile, "%s.debug/%s", dir, base);
1526 if (check_func (debugfile, func_data))
1527 goto found;
1529 #ifdef EXTRA_DEBUG_ROOT1
1530 /* Try the first extra debug file root. */
1531 sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT1,
1532 include_dirs ? canon_dir : "/", base);
1533 if (check_func (debugfile, func_data))
1534 goto found;
1535 #endif
1537 #ifdef EXTRA_DEBUG_ROOT2
1538 /* Try the second extra debug file root. */
1539 sprintf (debugfile, "%s%s%s", EXTRA_DEBUG_ROOT2,
1540 include_dirs ? canon_dir : "/", base);
1541 if (check_func (debugfile, func_data))
1542 goto found;
1543 #endif
1545 /* Then try in the global debugfile directory. */
1546 strcpy (debugfile, debug_file_directory);
1547 dirlen = strlen (debug_file_directory) - 1;
1548 if (include_dirs)
1550 if (dirlen > 0
1551 && debug_file_directory[dirlen] != '/'
1552 && canon_dir[0] != '/')
1553 strcat (debugfile, "/");
1554 strcat (debugfile, canon_dir);
1556 else
1558 if (dirlen > 0 && debug_file_directory[dirlen] != '/')
1559 strcat (debugfile, "/");
1561 strcat (debugfile, base);
1563 if (check_func (debugfile, func_data))
1564 goto found;
1566 /* Failed to find the file. */
1567 free (debugfile);
1568 debugfile = NULL;
1570 found:
1571 free (base);
1572 free (dir);
1573 free (canon_dir);
1574 return debugfile;
1578 FUNCTION
1579 bfd_follow_gnu_debuglink
1581 SYNOPSIS
1582 char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1584 DESCRIPTION
1585 Takes a BFD and searches it for a .gnu_debuglink section. If this
1586 section is found, it examines the section for the name and checksum
1587 of a '.debug' file containing auxiliary debugging information. It
1588 then searches the filesystem for this .debug file in some standard
1589 locations, including the directory tree rooted at @var{dir}, and if
1590 found returns the full filename.
1592 If @var{dir} is NULL, the search will take place starting at
1593 the current directory.
1595 Returns <<NULL>> on any errors or failure to locate the .debug
1596 file, otherwise a pointer to a heap-allocated string
1597 containing the filename. The caller is responsible for
1598 freeing this string.
1601 char *
1602 bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1604 uint32_t crc32;
1606 return find_separate_debug_file (abfd, dir, true,
1607 bfd_get_debug_link_info_1,
1608 separate_debug_file_exists, &crc32);
1611 /* Helper for bfd_follow_gnu_debugaltlink. It just returns the name
1612 of the separate debug file. */
1614 static char *
1615 get_alt_debug_link_info_shim (bfd * abfd, void *unused ATTRIBUTE_UNUSED)
1617 bfd_size_type len;
1618 bfd_byte *buildid = NULL;
1619 char *result = bfd_get_alt_debug_link_info (abfd, &len, &buildid);
1621 free (buildid);
1623 return result;
1627 FUNCTION
1628 bfd_follow_gnu_debugaltlink
1630 SYNOPSIS
1631 char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
1633 DESCRIPTION
1634 Takes a BFD and searches it for a .gnu_debugaltlink section. If this
1635 section is found, it examines the section for the name of a file
1636 containing auxiliary debugging information. It then searches the
1637 filesystem for this file in a set of standard locations, including
1638 the directory tree rooted at @var{dir}, and if found returns the
1639 full filename.
1641 If @var{dir} is NULL, the search will take place starting at
1642 the current directory.
1644 Returns <<NULL>> on any errors or failure to locate the debug
1645 file, otherwise a pointer to a heap-allocated string
1646 containing the filename. The caller is responsible for
1647 freeing this string.
1650 char *
1651 bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir)
1653 return find_separate_debug_file (abfd, dir, true,
1654 get_alt_debug_link_info_shim,
1655 separate_alt_debug_file_exists,
1656 NULL);
1660 FUNCTION
1661 bfd_create_gnu_debuglink_section
1663 SYNOPSIS
1664 struct bfd_section *bfd_create_gnu_debuglink_section
1665 (bfd *abfd, const char *filename);
1667 DESCRIPTION
1668 Takes a @var{BFD} and adds a .gnu_debuglink section to it. The
1669 section is sized to be big enough to contain a link to the specified
1670 @var{filename}.
1672 A pointer to the new section is returned if all is ok. Otherwise
1673 <<NULL>> is returned and bfd_error is set.
1676 asection *
1677 bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1679 asection *sect;
1680 bfd_size_type debuglink_size;
1681 flagword flags;
1683 if (abfd == NULL || filename == NULL)
1685 bfd_set_error (bfd_error_invalid_operation);
1686 return NULL;
1689 /* Strip off any path components in filename. */
1690 filename = lbasename (filename);
1692 sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1693 if (sect)
1695 /* Section already exists. */
1696 bfd_set_error (bfd_error_invalid_operation);
1697 return NULL;
1700 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1701 sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1702 if (sect == NULL)
1703 return NULL;
1705 /* Compute the size of the section. Allow for the CRC after the filename,
1706 and padding so that it will start on a 4-byte boundary. */
1707 debuglink_size = strlen (filename) + 1;
1708 debuglink_size += 3;
1709 debuglink_size &= ~3;
1710 debuglink_size += 4;
1712 if (!bfd_set_section_size (sect, debuglink_size))
1713 /* XXX Should we delete the section from the bfd ? */
1714 return NULL;
1716 /* PR 21193: Ensure that the section has 4-byte alignment for the CRC.
1717 Note - despite the name of the function being called, we are
1718 setting an alignment power, not a byte alignment value. */
1719 bfd_set_section_alignment (sect, 2);
1721 return sect;
1726 FUNCTION
1727 bfd_fill_in_gnu_debuglink_section
1729 SYNOPSIS
1730 bool bfd_fill_in_gnu_debuglink_section
1731 (bfd *abfd, struct bfd_section *sect, const char *filename);
1733 DESCRIPTION
1734 Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1735 and fills in the contents of the section to contain a link to the
1736 specified @var{filename}. The filename should be absolute or
1737 relative to the current directory.
1739 <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned
1740 and bfd_error is set.
1743 bool
1744 bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1745 struct bfd_section *sect,
1746 const char *filename)
1748 bfd_size_type debuglink_size;
1749 uint32_t crc32;
1750 char * contents;
1751 bfd_size_type crc_offset;
1752 FILE * handle;
1753 unsigned char buffer[8 * 1024];
1754 size_t count;
1755 size_t filelen;
1757 if (abfd == NULL || sect == NULL || filename == NULL)
1759 bfd_set_error (bfd_error_invalid_operation);
1760 return false;
1763 /* Open the linked file so that we can compute a CRC. */
1764 handle = _bfd_real_fopen (filename, FOPEN_RB);
1765 if (handle == NULL)
1767 bfd_set_error (bfd_error_system_call);
1768 return false;
1771 crc32 = 0;
1772 while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1773 crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1774 fclose (handle);
1776 /* Strip off any path components in filename,
1777 now that we no longer need them. */
1778 filename = lbasename (filename);
1780 filelen = strlen (filename);
1781 debuglink_size = filelen + 1;
1782 debuglink_size += 3;
1783 debuglink_size &= ~3;
1784 debuglink_size += 4;
1786 contents = (char *) bfd_malloc (debuglink_size);
1787 if (contents == NULL)
1789 /* XXX Should we delete the section from the bfd ? */
1790 return false;
1793 crc_offset = debuglink_size - 4;
1794 memcpy (contents, filename, filelen);
1795 memset (contents + filelen, 0, crc_offset - filelen);
1797 bfd_put_32 (abfd, crc32, contents + crc_offset);
1799 if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1801 /* XXX Should we delete the section from the bfd ? */
1802 free (contents);
1803 return false;
1806 return true;
1809 /* Finds the build-id associated with @var{abfd}. If the build-id is
1810 extracted from the note section then a build-id structure is built
1811 for it, using memory allocated to @var{abfd}, and this is then
1812 attached to the @var{abfd}.
1814 Returns a pointer to the build-id structure if a build-id could be
1815 found. If no build-id is found NULL is returned and error code is
1816 set. */
1818 static struct bfd_build_id *
1819 get_build_id (bfd *abfd)
1821 struct bfd_build_id *build_id;
1822 Elf_Internal_Note inote;
1823 Elf_External_Note *enote;
1824 bfd_byte *contents;
1825 asection *sect;
1826 bfd_size_type size;
1828 BFD_ASSERT (abfd);
1830 if (abfd->build_id && abfd->build_id->size > 0)
1831 /* Save some time by using the already computed build-id. */
1832 return (struct bfd_build_id *) abfd->build_id;
1834 sect = bfd_get_section_by_name (abfd, ".note.gnu.build-id");
1835 if (sect == NULL
1836 || (sect->flags & SEC_HAS_CONTENTS) == 0)
1838 bfd_set_error (bfd_error_no_debug_section);
1839 return NULL;
1842 size = bfd_section_size (sect);
1843 /* FIXME: Should we support smaller build-id notes ? */
1844 if (size < 0x24)
1846 bfd_set_error (bfd_error_invalid_operation);
1847 return NULL;
1850 if (!bfd_malloc_and_get_section (abfd, sect, & contents))
1851 return NULL;
1853 /* FIXME: Paranoia - allow for compressed build-id sections.
1854 Maybe we should complain if this size is different from
1855 the one obtained above... */
1856 size = bfd_section_size (sect);
1857 if (size < sizeof (Elf_External_Note))
1859 bfd_set_error (bfd_error_invalid_operation);
1860 free (contents);
1861 return NULL;
1864 enote = (Elf_External_Note *) contents;
1865 inote.type = H_GET_32 (abfd, enote->type);
1866 inote.namesz = H_GET_32 (abfd, enote->namesz);
1867 inote.namedata = enote->name;
1868 inote.descsz = H_GET_32 (abfd, enote->descsz);
1869 inote.descdata = inote.namedata + BFD_ALIGN (inote.namesz, 4);
1870 /* FIXME: Should we check for extra notes in this section ? */
1872 if (inote.descsz <= 0
1873 || inote.type != NT_GNU_BUILD_ID
1874 || inote.namesz != 4 /* sizeof "GNU" */
1875 || !startswith (inote.namedata, "GNU")
1876 || inote.descsz > 0x7ffffffe
1877 || size < (12 + BFD_ALIGN (inote.namesz, 4) + inote.descsz))
1879 free (contents);
1880 bfd_set_error (bfd_error_invalid_operation);
1881 return NULL;
1884 build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) + inote.descsz);
1885 if (build_id == NULL)
1887 free (contents);
1888 return NULL;
1891 build_id->size = inote.descsz;
1892 memcpy (build_id->data, inote.descdata, inote.descsz);
1893 abfd->build_id = build_id;
1894 free (contents);
1896 return build_id;
1899 /* Searches @var{abfd} for a build-id, and then constructs a pathname
1900 from it. The path is computed as .build-id/NN/NN+NN.debug where
1901 NNNN+NN is the build-id value as a hexadecimal string.
1903 Returns the constructed filename or NULL upon error. It is the
1904 caller's responsibility to free the memory used to hold the
1905 filename. If a filename is returned then the @var{build_id_out_p}
1906 parameter (which points to a @code{struct bfd_build_id} pointer) is
1907 set to a pointer to the build_id structure. */
1909 static char *
1910 get_build_id_name (bfd *abfd, void *build_id_out_p)
1912 struct bfd_build_id **build_id_out = build_id_out_p;
1913 struct bfd_build_id *build_id;
1914 char *name;
1915 char *n;
1916 bfd_size_type s;
1917 bfd_byte *d;
1919 if (abfd == NULL || bfd_get_filename (abfd) == NULL || build_id_out == NULL)
1921 bfd_set_error (bfd_error_invalid_operation);
1922 return NULL;
1925 build_id = get_build_id (abfd);
1926 if (build_id == NULL)
1927 return NULL;
1929 /* Compute the debug pathname corresponding to the build-id. */
1930 name = bfd_malloc (strlen (".build-id/") + build_id->size * 2 + 2 + strlen (".debug"));
1931 if (name == NULL)
1933 bfd_set_error (bfd_error_no_memory);
1934 return NULL;
1936 n = name;
1937 d = build_id->data;
1938 s = build_id->size;
1940 n += sprintf (n, ".build-id/");
1941 n += sprintf (n, "%02x", (unsigned) *d++); s--;
1942 n += sprintf (n, "/");
1943 while (s--)
1944 n += sprintf (n, "%02x", (unsigned) *d++);
1945 n += sprintf (n, ".debug");
1947 *build_id_out = build_id;
1948 return name;
1951 /* Checks to see if @var{name} is a readable file and if its build-id
1952 matches @var{buildid}.
1954 Returns TRUE if the file exists, is readable, and contains a
1955 build-id which matches the build-id pointed at by @var{build_id_p}
1956 (which is really a @code{struct bfd_build_id **}). */
1958 static bool
1959 check_build_id_file (const char *name, void *buildid_p)
1961 struct bfd_build_id *orig_build_id;
1962 struct bfd_build_id *build_id;
1963 bfd * file;
1964 bool result;
1966 BFD_ASSERT (name);
1967 BFD_ASSERT (buildid_p);
1969 file = bfd_openr (name, NULL);
1970 if (file == NULL)
1971 return false;
1973 /* If the file is an archive, process all of its elements. */
1974 if (! bfd_check_format (file, bfd_object))
1976 bfd_close (file);
1977 return false;
1980 build_id = get_build_id (file);
1981 if (build_id == NULL)
1983 bfd_close (file);
1984 return false;
1987 orig_build_id = *(struct bfd_build_id **) buildid_p;
1989 result = build_id->size == orig_build_id->size
1990 && memcmp (build_id->data, orig_build_id->data, build_id->size) == 0;
1992 (void) bfd_close (file);
1994 return result;
1998 FUNCTION
1999 bfd_follow_build_id_debuglink
2001 SYNOPSIS
2002 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
2004 DESCRIPTION
2005 Takes @var{abfd} and searches it for a .note.gnu.build-id section.
2006 If this section is found, it extracts the value of the NT_GNU_BUILD_ID
2007 note, which should be a hexadecimal value @var{NNNN+NN} (for
2008 32+ hex digits). It then searches the filesystem for a file named
2009 @var{.build-id/NN/NN+NN.debug} in a set of standard locations,
2010 including the directory tree rooted at @var{dir}. The filename
2011 of the first matching file to be found is returned. A matching
2012 file should contain a .note.gnu.build-id section with the same
2013 @var{NNNN+NN} note as @var{abfd}, although this check is currently
2014 not implemented.
2016 If @var{dir} is NULL, the search will take place starting at
2017 the current directory.
2019 Returns <<NULL>> on any errors or failure to locate the debug
2020 file, otherwise a pointer to a heap-allocated string
2021 containing the filename. The caller is responsible for
2022 freeing this string.
2025 char *
2026 bfd_follow_build_id_debuglink (bfd *abfd, const char *dir)
2028 struct bfd_build_id *build_id;
2030 return find_separate_debug_file (abfd, dir, false,
2031 get_build_id_name,
2032 check_build_id_file, &build_id);
2036 FUNCTION
2037 bfd_set_filename
2039 SYNOPSIS
2040 const char *bfd_set_filename (bfd *abfd, const char *filename);
2042 DESCRIPTION
2043 Set the filename of @var{abfd}, copying the FILENAME parameter to
2044 bfd_alloc'd memory owned by @var{abfd}. Returns a pointer the
2045 newly allocated name, or NULL if the allocation failed.
2048 const char *
2049 bfd_set_filename (bfd *abfd, const char *filename)
2051 size_t len = strlen (filename) + 1;
2052 char *n = bfd_alloc (abfd, len);
2054 if (n == NULL)
2055 return NULL;
2057 if (abfd->filename != NULL)
2059 /* PR 29389. If we attempt to rename a file that has been closed due
2060 to caching, then we will not be able to reopen it later on. */
2061 if (abfd->iostream == NULL && (abfd->flags & BFD_CLOSED_BY_CACHE))
2063 bfd_set_error (bfd_error_invalid_operation);
2064 return NULL;
2067 /* Similarly if we attempt to close a renamed file because the
2068 cache is now full, we will not be able to reopen it later on. */
2069 if (abfd->iostream != NULL)
2070 abfd->cacheable = 0;
2073 memcpy (n, filename, len);
2074 abfd->filename = n;
2076 return n;