1 /* Definitions for BFD wrappers used by GDB.
3 Copyright (C) 2011-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "filestuff.h"
30 #define MAP_FAILED ((void *) -1)
34 #include "gdb/fileio.h"
40 /* An object of this type is stored in the section's user data when
43 struct gdb_bfd_section_data
45 /* Size of the data. */
47 /* If the data was mmapped, this is the length of the map. */
48 bfd_size_type map_len;
49 /* The data. If NULL, the section data has not been read. */
51 /* If the data was mmapped, this is the map address. */
55 /* A hash table holding every BFD that gdb knows about. This is not
56 to be confused with 'gdb_bfd_cache', which is used for sharing
57 BFDs; in contrast, this hash is used just to implement
60 static htab_t all_bfds;
62 /* An object of this type is stored in each BFD's user data. */
66 /* The reference count. */
69 /* The mtime of the BFD at the point the cache entry was made. */
72 /* The file size (in bytes) at the point the cache entry was made. */
75 /* The inode of the file at the point the cache entry was made. */
78 /* The device id of the file at the point the cache entry was made. */
81 /* This is true if we have determined whether this BFD has any
82 sections requiring relocation. */
83 unsigned int relocation_computed : 1;
85 /* This is true if any section needs relocation. */
86 unsigned int needs_relocations : 1;
88 /* This is true if we have successfully computed the file's CRC. */
89 unsigned int crc_computed : 1;
94 /* If the BFD comes from an archive, this points to the archive's
95 BFD. Otherwise, this is NULL. */
98 /* Table of all the bfds this bfd has included. */
99 VEC (bfdp) *included_bfds;
105 #define GDB_BFD_DATA_ACCESSOR(ABFD) \
106 ((struct gdb_bfd_data *) bfd_usrdata (ABFD))
108 DEFINE_REGISTRY (bfd, GDB_BFD_DATA_ACCESSOR)
110 /* A hash table storing all the BFDs maintained in the cache. */
112 static htab_t gdb_bfd_cache;
114 /* When true gdb will reuse an existing bfd object if the filename,
115 modification time, and file size all match. */
117 static int bfd_sharing = 1;
119 show_bfd_sharing (struct ui_file *file, int from_tty,
120 struct cmd_list_element *c, const char *value)
122 fprintf_filtered (file, _("BFD sharing is %s.\n"), value);
125 /* When non-zero debugging of the bfd caches is enabled. */
127 static unsigned int debug_bfd_cache;
129 show_bfd_cache_debug (struct ui_file *file, int from_tty,
130 struct cmd_list_element *c, const char *value)
132 fprintf_filtered (file, _("BFD cache debugging is %s.\n"), value);
135 /* The type of an object being looked up in gdb_bfd_cache. We use
136 htab's capability of storing one kind of object (BFD in this case)
137 and using a different sort of object for searching. */
139 struct gdb_bfd_cache_search
142 const char *filename;
145 /* The file size (in bytes). */
147 /* The inode of the file. */
149 /* The device id of the file. */
153 /* A hash function for BFDs. */
156 hash_bfd (const void *b)
160 /* It is simplest to just hash the filename. */
161 return htab_hash_string (bfd_get_filename (abfd));
164 /* An equality function for BFDs. Note that this expects the caller
165 to search using struct gdb_bfd_cache_search only, not BFDs. */
168 eq_bfd (const void *a, const void *b)
171 const struct gdb_bfd_cache_search *s = b;
172 struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
174 return (gdata->mtime == s->mtime
175 && gdata->size == s->size
176 && gdata->inode == s->inode
177 && gdata->device_id == s->device_id
178 && strcmp (bfd_get_filename (abfd), s->filename) == 0);
184 is_target_filename (const char *name)
186 return startswith (name, TARGET_SYSROOT_PREFIX);
192 gdb_bfd_has_target_filename (struct bfd *abfd)
194 return is_target_filename (bfd_get_filename (abfd));
198 /* Return the system error number corresponding to ERRNUM. */
201 fileio_errno_to_host (int errnum)
245 case FILEIO_ENAMETOOLONG:
251 /* Wrapper for target_fileio_open suitable for passing as the
252 OPEN_FUNC argument to gdb_bfd_openr_iovec. The supplied
253 OPEN_CLOSURE is unused. */
256 gdb_bfd_iovec_fileio_open (struct bfd *abfd, void *inferior)
258 const char *filename = bfd_get_filename (abfd);
259 int fd, target_errno;
262 gdb_assert (is_target_filename (filename));
264 fd = target_fileio_open_warn_if_slow ((struct inferior *) inferior,
266 + strlen (TARGET_SYSROOT_PREFIX),
271 errno = fileio_errno_to_host (target_errno);
272 bfd_set_error (bfd_error_system_call);
276 stream = XCNEW (int);
281 /* Wrapper for target_fileio_pread suitable for passing as the
282 PREAD_FUNC argument to gdb_bfd_openr_iovec. */
285 gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf,
286 file_ptr nbytes, file_ptr offset)
288 int fd = *(int *) stream;
297 bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos,
298 nbytes - pos, offset + pos,
301 /* Success, but no bytes, means end-of-file. */
305 errno = fileio_errno_to_host (target_errno);
306 bfd_set_error (bfd_error_system_call);
316 /* Wrapper for target_fileio_close suitable for passing as the
317 CLOSE_FUNC argument to gdb_bfd_openr_iovec. */
320 gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream)
322 int fd = *(int *) stream;
327 /* Ignore errors on close. These may happen with remote
328 targets if the connection has already been torn down. */
329 target_fileio_close (fd, &target_errno);
331 /* Zero means success. */
335 /* Wrapper for target_fileio_fstat suitable for passing as the
336 STAT_FUNC argument to gdb_bfd_openr_iovec. */
339 gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream,
342 int fd = *(int *) stream;
346 result = target_fileio_fstat (fd, sb, &target_errno);
349 errno = fileio_errno_to_host (target_errno);
350 bfd_set_error (bfd_error_system_call);
359 gdb_bfd_open (const char *name, const char *target, int fd)
364 struct gdb_bfd_cache_search search;
367 if (is_target_filename (name))
369 if (!target_filesystem_is_local ())
371 gdb_assert (fd == -1);
373 return gdb_bfd_openr_iovec (name, target,
374 gdb_bfd_iovec_fileio_open,
376 gdb_bfd_iovec_fileio_pread,
377 gdb_bfd_iovec_fileio_close,
378 gdb_bfd_iovec_fileio_fstat);
381 name += strlen (TARGET_SYSROOT_PREFIX);
384 if (gdb_bfd_cache == NULL)
385 gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
390 fd = gdb_open_cloexec (name, O_RDONLY | O_BINARY, 0);
393 bfd_set_error (bfd_error_system_call);
398 search.filename = name;
399 if (fstat (fd, &st) < 0)
401 /* Weird situation here. */
405 search.device_id = 0;
409 search.mtime = st.st_mtime;
410 search.size = st.st_size;
411 search.inode = st.st_ino;
412 search.device_id = st.st_dev;
415 /* Note that this must compute the same result as hash_bfd. */
416 hash = htab_hash_string (name);
417 /* Note that we cannot use htab_find_slot_with_hash here, because
418 opening the BFD may fail; and this would violate hashtab
420 abfd = htab_find_with_hash (gdb_bfd_cache, &search, hash);
421 if (bfd_sharing && abfd != NULL)
424 fprintf_unfiltered (gdb_stdlog,
425 "Reusing cached bfd %s for %s\n",
426 host_address_to_string (abfd),
427 bfd_get_filename (abfd));
433 abfd = bfd_fopen (name, target, FOPEN_RB, fd);
438 fprintf_unfiltered (gdb_stdlog,
439 "Creating new bfd %s for %s\n",
440 host_address_to_string (abfd),
441 bfd_get_filename (abfd));
445 slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
454 /* A helper function that releases any section data attached to the
458 free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
460 struct gdb_bfd_section_data *sect = bfd_get_section_userdata (abfd, sectp);
462 if (sect != NULL && sect->data != NULL)
465 if (sect->map_addr != NULL)
469 res = munmap (sect->map_addr, sect->map_len);
470 gdb_assert (res == 0);
478 /* Close ABFD, and warn if that fails. */
481 gdb_bfd_close_or_warn (struct bfd *abfd)
484 char *name = bfd_get_filename (abfd);
486 bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
488 ret = bfd_close (abfd);
491 warning (_("cannot close \"%s\": %s"),
492 name, bfd_errmsg (bfd_get_error ()));
500 gdb_bfd_ref (struct bfd *abfd)
503 struct gdb_bfd_data *gdata;
509 gdata = bfd_usrdata (abfd);
512 fprintf_unfiltered (gdb_stdlog,
513 "Increase reference count on bfd %s (%s)\n",
514 host_address_to_string (abfd),
515 bfd_get_filename (abfd));
523 /* Ask BFD to decompress sections in bfd_get_full_section_contents. */
524 abfd->flags |= BFD_DECOMPRESS;
527 = (struct gdb_bfd_data *) bfd_zalloc (abfd, sizeof (struct gdb_bfd_data));
529 gdata->mtime = bfd_get_mtime (abfd);
530 gdata->size = bfd_get_size (abfd);
531 gdata->archive_bfd = NULL;
532 if (bfd_stat (abfd, &buf) == 0)
534 gdata->inode = buf.st_ino;
535 gdata->device_id = buf.st_dev;
539 /* The stat failed. */
541 gdata->device_id = 0;
543 bfd_usrdata (abfd) = gdata;
545 bfd_alloc_data (abfd);
547 /* This is the first we've seen it, so add it to the hash table. */
548 slot = htab_find_slot (all_bfds, abfd, INSERT);
549 gdb_assert (slot && !*slot);
556 gdb_bfd_unref (struct bfd *abfd)
559 struct gdb_bfd_data *gdata;
560 struct gdb_bfd_cache_search search;
561 bfd *archive_bfd, *included_bfd;
566 gdata = bfd_usrdata (abfd);
567 gdb_assert (gdata->refc >= 1);
573 fprintf_unfiltered (gdb_stdlog,
574 "Decrease reference count on bfd %s (%s)\n",
575 host_address_to_string (abfd),
576 bfd_get_filename (abfd));
581 fprintf_unfiltered (gdb_stdlog,
582 "Delete final reference count on bfd %s (%s)\n",
583 host_address_to_string (abfd),
584 bfd_get_filename (abfd));
586 archive_bfd = gdata->archive_bfd;
587 search.filename = bfd_get_filename (abfd);
589 if (gdb_bfd_cache && search.filename)
591 hashval_t hash = htab_hash_string (search.filename);
594 search.mtime = gdata->mtime;
595 search.size = gdata->size;
596 search.inode = gdata->inode;
597 search.device_id = gdata->device_id;
598 slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
602 htab_clear_slot (gdb_bfd_cache, slot);
606 VEC_iterate (bfdp, gdata->included_bfds, ix, included_bfd);
608 gdb_bfd_unref (included_bfd);
609 VEC_free (bfdp, gdata->included_bfds);
611 bfd_free_data (abfd);
612 bfd_usrdata (abfd) = NULL; /* Paranoia. */
614 htab_remove_elt (all_bfds, abfd);
616 gdb_bfd_close_or_warn (abfd);
618 gdb_bfd_unref (archive_bfd);
621 /* A helper function that returns the section data descriptor
622 associated with SECTION. If no such descriptor exists, a new one
623 is allocated and cleared. */
625 static struct gdb_bfd_section_data *
626 get_section_descriptor (asection *section)
628 struct gdb_bfd_section_data *result;
630 result = bfd_get_section_userdata (section->owner, section);
634 result = ((struct gdb_bfd_section_data *)
635 bfd_zalloc (section->owner, sizeof (*result)));
636 bfd_set_section_userdata (section->owner, section, result);
645 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
648 struct gdb_bfd_section_data *descriptor;
651 gdb_assert ((sectp->flags & SEC_RELOC) == 0);
652 gdb_assert (size != NULL);
656 descriptor = get_section_descriptor (sectp);
658 /* If the data was already read for this BFD, just reuse it. */
659 if (descriptor->data != NULL)
663 if (!bfd_is_section_compressed (abfd, sectp))
665 /* The page size, used when mmapping. */
669 pagesize = getpagesize ();
671 /* Only try to mmap sections which are large enough: we don't want
672 to waste space due to fragmentation. */
674 if (bfd_get_section_size (sectp) > 4 * pagesize)
676 descriptor->size = bfd_get_section_size (sectp);
677 descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
678 MAP_PRIVATE, sectp->filepos,
679 &descriptor->map_addr,
680 &descriptor->map_len);
682 if ((caddr_t)descriptor->data != MAP_FAILED)
684 #if HAVE_POSIX_MADVISE
685 posix_madvise (descriptor->map_addr, descriptor->map_len,
686 POSIX_MADV_WILLNEED);
691 /* On failure, clear out the section data and try again. */
692 memset (descriptor, 0, sizeof (*descriptor));
695 #endif /* HAVE_MMAP */
697 /* Handle compressed sections, or ordinary uncompressed sections in
700 descriptor->size = bfd_get_section_size (sectp);
701 descriptor->data = NULL;
704 if (!bfd_get_full_section_contents (abfd, sectp, &data))
705 error (_("Can't read data for section '%s' in file '%s'"),
706 bfd_get_section_name (abfd, sectp),
707 bfd_get_filename (abfd));
708 descriptor->data = data;
711 gdb_assert (descriptor->data != NULL);
712 *size = descriptor->size;
713 return descriptor->data;
716 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
717 return 1. Otherwise print a warning and return 0. ABFD seek position is
721 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
723 unsigned long file_crc = 0;
725 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
727 warning (_("Problem reading \"%s\" for CRC: %s"),
728 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
734 gdb_byte buffer[8 * 1024];
737 count = bfd_bread (buffer, sizeof (buffer), abfd);
738 if (count == (bfd_size_type) -1)
740 warning (_("Problem reading \"%s\" for CRC: %s"),
741 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
746 file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
749 *file_crc_return = file_crc;
756 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
758 struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
760 if (!gdata->crc_computed)
761 gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
763 if (gdata->crc_computed)
764 *crc_out = gdata->crc;
765 return gdata->crc_computed;
773 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
776 bfd *result = bfd_fopen (filename, target, mode, fd);
779 gdb_bfd_ref (result);
787 gdb_bfd_openr (const char *filename, const char *target)
789 bfd *result = bfd_openr (filename, target);
792 gdb_bfd_ref (result);
800 gdb_bfd_openw (const char *filename, const char *target)
802 bfd *result = bfd_openw (filename, target);
805 gdb_bfd_ref (result);
813 gdb_bfd_openr_iovec (const char *filename, const char *target,
814 void *(*open_func) (struct bfd *nbfd,
817 file_ptr (*pread_func) (struct bfd *nbfd,
822 int (*close_func) (struct bfd *nbfd,
824 int (*stat_func) (struct bfd *abfd,
828 bfd *result = bfd_openr_iovec (filename, target,
829 open_func, open_closure,
830 pread_func, close_func, stat_func);
833 gdb_bfd_ref (result);
841 gdb_bfd_mark_parent (bfd *child, bfd *parent)
843 struct gdb_bfd_data *gdata;
846 /* No need to stash the filename here, because we also keep a
847 reference on the parent archive. */
849 gdata = bfd_usrdata (child);
850 if (gdata->archive_bfd == NULL)
852 gdata->archive_bfd = parent;
853 gdb_bfd_ref (parent);
856 gdb_assert (gdata->archive_bfd == parent);
862 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
864 bfd *result = bfd_openr_next_archived_file (archive, previous);
867 gdb_bfd_mark_parent (result, archive);
875 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
877 struct gdb_bfd_data *gdata;
879 gdb_bfd_ref (includee);
880 gdata = bfd_usrdata (includer);
881 VEC_safe_push (bfdp, gdata->included_bfds, includee);
887 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
889 bfd *result = bfd_fdopenr (filename, target, fd);
892 gdb_bfd_ref (result);
899 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
904 gdb_bfd_section_index (bfd *abfd, asection *section)
908 else if (section == bfd_com_section_ptr)
909 return bfd_count_sections (abfd);
910 else if (section == bfd_und_section_ptr)
911 return bfd_count_sections (abfd) + 1;
912 else if (section == bfd_abs_section_ptr)
913 return bfd_count_sections (abfd) + 2;
914 else if (section == bfd_ind_section_ptr)
915 return bfd_count_sections (abfd) + 3;
916 return section->index;
922 gdb_bfd_count_sections (bfd *abfd)
924 return bfd_count_sections (abfd) + 4;
930 gdb_bfd_requires_relocations (bfd *abfd)
932 struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
934 if (gdata->relocation_computed == 0)
938 for (sect = abfd->sections; sect != NULL; sect = sect->next)
939 if ((sect->flags & SEC_RELOC) != 0)
941 gdata->needs_relocations = 1;
945 gdata->relocation_computed = 1;
948 return gdata->needs_relocations;
953 /* A callback for htab_traverse that prints a single BFD. */
956 print_one_bfd (void **slot, void *data)
959 struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
960 struct ui_out *uiout = data;
961 struct cleanup *inner;
963 inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
964 ui_out_field_int (uiout, "refcount", gdata->refc);
965 ui_out_field_string (uiout, "addr", host_address_to_string (abfd));
966 ui_out_field_string (uiout, "filename", bfd_get_filename (abfd));
967 ui_out_text (uiout, "\n");
973 /* Implement the 'maint info bfd' command. */
976 maintenance_info_bfds (char *arg, int from_tty)
978 struct cleanup *cleanup;
979 struct ui_out *uiout = current_uiout;
981 cleanup = make_cleanup_ui_out_table_begin_end (uiout, 3, -1, "bfds");
982 ui_out_table_header (uiout, 10, ui_left, "refcount", "Refcount");
983 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
984 ui_out_table_header (uiout, 40, ui_left, "filename", "Filename");
986 ui_out_table_body (uiout);
987 htab_traverse (all_bfds, print_one_bfd, uiout);
989 do_cleanups (cleanup);
992 /* -Wmissing-prototypes */
993 extern initialize_file_ftype _initialize_gdb_bfd;
996 _initialize_gdb_bfd (void)
998 all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
999 NULL, xcalloc, xfree);
1001 add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
1002 List the BFDs that are currently open."),
1003 &maintenanceinfolist);
1005 add_setshow_boolean_cmd ("bfd-sharing", no_class,
1007 Set whether gdb will share bfds that appear to be the same file."), _("\
1008 Show whether gdb will share bfds that appear to be the same file."), _("\
1009 When enabled gdb will reuse existing bfds rather than reopening the\n\
1010 same file. To decide if two files are the same then gdb compares the\n\
1011 filename, file size, file modification time, and file inode."),
1014 &maintenance_set_cmdlist,
1015 &maintenance_show_cmdlist);
1017 add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
1018 &debug_bfd_cache, _("\
1019 Set bfd cache debugging."), _("\
1020 Show bfd cache debugging."), _("\
1021 When non-zero, bfd cache specific debugging is enabled."),
1023 &show_bfd_cache_debug,
1024 &setdebuglist, &showdebuglist);