1 /* Definitions for BFD wrappers used by GDB.
3 Copyright (C) 2011-2017 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"
37 /* An object of this type is stored in the section's user data when
40 struct gdb_bfd_section_data
42 /* Size of the data. */
44 /* If the data was mmapped, this is the length of the map. */
45 bfd_size_type map_len;
46 /* The data. If NULL, the section data has not been read. */
48 /* If the data was mmapped, this is the map address. */
52 /* A hash table holding every BFD that gdb knows about. This is not
53 to be confused with 'gdb_bfd_cache', which is used for sharing
54 BFDs; in contrast, this hash is used just to implement
57 static htab_t all_bfds;
59 /* An object of this type is stored in each BFD's user data. */
63 gdb_bfd_data (bfd *abfd)
64 : mtime (bfd_get_mtime (abfd)),
65 size (bfd_get_size (abfd)),
66 relocation_computed (0),
67 needs_relocations (0),
72 if (bfd_stat (abfd, &buf) == 0)
75 device_id = buf.st_dev;
79 /* The stat failed. */
89 /* The reference count. */
92 /* The mtime of the BFD at the point the cache entry was made. */
95 /* The file size (in bytes) at the point the cache entry was made. */
98 /* The inode of the file at the point the cache entry was made. */
101 /* The device id of the file at the point the cache entry was made. */
104 /* This is true if we have determined whether this BFD has any
105 sections requiring relocation. */
106 unsigned int relocation_computed : 1;
108 /* This is true if any section needs relocation. */
109 unsigned int needs_relocations : 1;
111 /* This is true if we have successfully computed the file's CRC. */
112 unsigned int crc_computed : 1;
114 /* The file's CRC. */
115 unsigned long crc = 0;
117 /* If the BFD comes from an archive, this points to the archive's
118 BFD. Otherwise, this is NULL. */
119 bfd *archive_bfd = nullptr;
121 /* Table of all the bfds this bfd has included. */
122 std::vector<gdb_bfd_ref_ptr> included_bfds;
125 REGISTRY_FIELDS = {};
128 #define GDB_BFD_DATA_ACCESSOR(ABFD) \
129 ((struct gdb_bfd_data *) bfd_usrdata (ABFD))
131 DEFINE_REGISTRY (bfd, GDB_BFD_DATA_ACCESSOR)
133 /* A hash table storing all the BFDs maintained in the cache. */
135 static htab_t gdb_bfd_cache;
137 /* When true gdb will reuse an existing bfd object if the filename,
138 modification time, and file size all match. */
140 static int bfd_sharing = 1;
142 show_bfd_sharing (struct ui_file *file, int from_tty,
143 struct cmd_list_element *c, const char *value)
145 fprintf_filtered (file, _("BFD sharing is %s.\n"), value);
148 /* When non-zero debugging of the bfd caches is enabled. */
150 static unsigned int debug_bfd_cache;
152 show_bfd_cache_debug (struct ui_file *file, int from_tty,
153 struct cmd_list_element *c, const char *value)
155 fprintf_filtered (file, _("BFD cache debugging is %s.\n"), value);
158 /* The type of an object being looked up in gdb_bfd_cache. We use
159 htab's capability of storing one kind of object (BFD in this case)
160 and using a different sort of object for searching. */
162 struct gdb_bfd_cache_search
165 const char *filename;
168 /* The file size (in bytes). */
170 /* The inode of the file. */
172 /* The device id of the file. */
176 /* A hash function for BFDs. */
179 hash_bfd (const void *b)
181 const bfd *abfd = (const struct bfd *) b;
183 /* It is simplest to just hash the filename. */
184 return htab_hash_string (bfd_get_filename (abfd));
187 /* An equality function for BFDs. Note that this expects the caller
188 to search using struct gdb_bfd_cache_search only, not BFDs. */
191 eq_bfd (const void *a, const void *b)
193 const bfd *abfd = (const struct bfd *) a;
194 const struct gdb_bfd_cache_search *s
195 = (const struct gdb_bfd_cache_search *) b;
196 struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
198 return (gdata->mtime == s->mtime
199 && gdata->size == s->size
200 && gdata->inode == s->inode
201 && gdata->device_id == s->device_id
202 && strcmp (bfd_get_filename (abfd), s->filename) == 0);
208 is_target_filename (const char *name)
210 return startswith (name, TARGET_SYSROOT_PREFIX);
216 gdb_bfd_has_target_filename (struct bfd *abfd)
218 return is_target_filename (bfd_get_filename (abfd));
222 /* Return the system error number corresponding to ERRNUM. */
225 fileio_errno_to_host (int errnum)
269 case FILEIO_ENAMETOOLONG:
275 /* Wrapper for target_fileio_open suitable for passing as the
276 OPEN_FUNC argument to gdb_bfd_openr_iovec. The supplied
277 OPEN_CLOSURE is unused. */
280 gdb_bfd_iovec_fileio_open (struct bfd *abfd, void *inferior)
282 const char *filename = bfd_get_filename (abfd);
283 int fd, target_errno;
286 gdb_assert (is_target_filename (filename));
288 fd = target_fileio_open_warn_if_slow ((struct inferior *) inferior,
290 + strlen (TARGET_SYSROOT_PREFIX),
295 errno = fileio_errno_to_host (target_errno);
296 bfd_set_error (bfd_error_system_call);
300 stream = XCNEW (int);
305 /* Wrapper for target_fileio_pread suitable for passing as the
306 PREAD_FUNC argument to gdb_bfd_openr_iovec. */
309 gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf,
310 file_ptr nbytes, file_ptr offset)
312 int fd = *(int *) stream;
321 bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos,
322 nbytes - pos, offset + pos,
325 /* Success, but no bytes, means end-of-file. */
329 errno = fileio_errno_to_host (target_errno);
330 bfd_set_error (bfd_error_system_call);
340 /* Wrapper for target_fileio_close suitable for passing as the
341 CLOSE_FUNC argument to gdb_bfd_openr_iovec. */
344 gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream)
346 int fd = *(int *) stream;
351 /* Ignore errors on close. These may happen with remote
352 targets if the connection has already been torn down. */
353 target_fileio_close (fd, &target_errno);
355 /* Zero means success. */
359 /* Wrapper for target_fileio_fstat suitable for passing as the
360 STAT_FUNC argument to gdb_bfd_openr_iovec. */
363 gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream,
366 int fd = *(int *) stream;
370 result = target_fileio_fstat (fd, sb, &target_errno);
373 errno = fileio_errno_to_host (target_errno);
374 bfd_set_error (bfd_error_system_call);
383 gdb_bfd_open (const char *name, const char *target, int fd)
388 struct gdb_bfd_cache_search search;
391 if (is_target_filename (name))
393 if (!target_filesystem_is_local ())
395 gdb_assert (fd == -1);
397 return gdb_bfd_openr_iovec (name, target,
398 gdb_bfd_iovec_fileio_open,
400 gdb_bfd_iovec_fileio_pread,
401 gdb_bfd_iovec_fileio_close,
402 gdb_bfd_iovec_fileio_fstat);
405 name += strlen (TARGET_SYSROOT_PREFIX);
408 if (gdb_bfd_cache == NULL)
409 gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
414 fd = gdb_open_cloexec (name, O_RDONLY | O_BINARY, 0);
417 bfd_set_error (bfd_error_system_call);
422 search.filename = name;
423 if (fstat (fd, &st) < 0)
425 /* Weird situation here. */
429 search.device_id = 0;
433 search.mtime = st.st_mtime;
434 search.size = st.st_size;
435 search.inode = st.st_ino;
436 search.device_id = st.st_dev;
439 /* Note that this must compute the same result as hash_bfd. */
440 hash = htab_hash_string (name);
441 /* Note that we cannot use htab_find_slot_with_hash here, because
442 opening the BFD may fail; and this would violate hashtab
444 abfd = (struct bfd *) htab_find_with_hash (gdb_bfd_cache, &search, hash);
445 if (bfd_sharing && abfd != NULL)
448 fprintf_unfiltered (gdb_stdlog,
449 "Reusing cached bfd %s for %s\n",
450 host_address_to_string (abfd),
451 bfd_get_filename (abfd));
453 return new_bfd_ref (abfd);
456 abfd = bfd_fopen (name, target, FOPEN_RB, fd);
461 fprintf_unfiltered (gdb_stdlog,
462 "Creating new bfd %s for %s\n",
463 host_address_to_string (abfd),
464 bfd_get_filename (abfd));
468 slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
473 return new_bfd_ref (abfd);
476 /* A helper function that releases any section data attached to the
480 free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
482 struct gdb_bfd_section_data *sect
483 = (struct gdb_bfd_section_data *) bfd_get_section_userdata (abfd, sectp);
485 if (sect != NULL && sect->data != NULL)
488 if (sect->map_addr != NULL)
492 res = munmap (sect->map_addr, sect->map_len);
493 gdb_assert (res == 0);
501 /* Close ABFD, and warn if that fails. */
504 gdb_bfd_close_or_warn (struct bfd *abfd)
507 char *name = bfd_get_filename (abfd);
509 bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
511 ret = bfd_close (abfd);
514 warning (_("cannot close \"%s\": %s"),
515 name, bfd_errmsg (bfd_get_error ()));
523 gdb_bfd_ref (struct bfd *abfd)
525 struct gdb_bfd_data *gdata;
531 gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
534 fprintf_unfiltered (gdb_stdlog,
535 "Increase reference count on bfd %s (%s)\n",
536 host_address_to_string (abfd),
537 bfd_get_filename (abfd));
545 /* Ask BFD to decompress sections in bfd_get_full_section_contents. */
546 abfd->flags |= BFD_DECOMPRESS;
548 gdata = new gdb_bfd_data (abfd);
549 bfd_usrdata (abfd) = gdata;
550 bfd_alloc_data (abfd);
552 /* This is the first we've seen it, so add it to the hash table. */
553 slot = htab_find_slot (all_bfds, abfd, INSERT);
554 gdb_assert (slot && !*slot);
561 gdb_bfd_unref (struct bfd *abfd)
563 struct gdb_bfd_data *gdata;
564 struct gdb_bfd_cache_search search;
570 gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
571 gdb_assert (gdata->refc >= 1);
577 fprintf_unfiltered (gdb_stdlog,
578 "Decrease reference count on bfd %s (%s)\n",
579 host_address_to_string (abfd),
580 bfd_get_filename (abfd));
585 fprintf_unfiltered (gdb_stdlog,
586 "Delete final reference count on bfd %s (%s)\n",
587 host_address_to_string (abfd),
588 bfd_get_filename (abfd));
590 archive_bfd = gdata->archive_bfd;
591 search.filename = bfd_get_filename (abfd);
593 if (gdb_bfd_cache && search.filename)
595 hashval_t hash = htab_hash_string (search.filename);
598 search.mtime = gdata->mtime;
599 search.size = gdata->size;
600 search.inode = gdata->inode;
601 search.device_id = gdata->device_id;
602 slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
606 htab_clear_slot (gdb_bfd_cache, slot);
609 bfd_free_data (abfd);
611 bfd_usrdata (abfd) = NULL; /* Paranoia. */
613 htab_remove_elt (all_bfds, abfd);
615 gdb_bfd_close_or_warn (abfd);
617 gdb_bfd_unref (archive_bfd);
620 /* A helper function that returns the section data descriptor
621 associated with SECTION. If no such descriptor exists, a new one
622 is allocated and cleared. */
624 static struct gdb_bfd_section_data *
625 get_section_descriptor (asection *section)
627 struct gdb_bfd_section_data *result;
629 result = ((struct gdb_bfd_section_data *)
630 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 (const gdb_byte *) 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 = (struct gdb_bfd_data *) 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);
778 return new_bfd_ref (result);
784 gdb_bfd_openr (const char *filename, const char *target)
786 bfd *result = bfd_openr (filename, target);
788 return new_bfd_ref (result);
794 gdb_bfd_openw (const char *filename, const char *target)
796 bfd *result = bfd_openw (filename, target);
798 return new_bfd_ref (result);
804 gdb_bfd_openr_iovec (const char *filename, const char *target,
805 void *(*open_func) (struct bfd *nbfd,
808 file_ptr (*pread_func) (struct bfd *nbfd,
813 int (*close_func) (struct bfd *nbfd,
815 int (*stat_func) (struct bfd *abfd,
819 bfd *result = bfd_openr_iovec (filename, target,
820 open_func, open_closure,
821 pread_func, close_func, stat_func);
823 return new_bfd_ref (result);
829 gdb_bfd_mark_parent (bfd *child, bfd *parent)
831 struct gdb_bfd_data *gdata;
834 /* No need to stash the filename here, because we also keep a
835 reference on the parent archive. */
837 gdata = (struct gdb_bfd_data *) bfd_usrdata (child);
838 if (gdata->archive_bfd == NULL)
840 gdata->archive_bfd = parent;
841 gdb_bfd_ref (parent);
844 gdb_assert (gdata->archive_bfd == parent);
850 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
852 bfd *result = bfd_openr_next_archived_file (archive, previous);
855 gdb_bfd_mark_parent (result, archive);
857 return gdb_bfd_ref_ptr (result);
863 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
865 struct gdb_bfd_data *gdata;
867 gdata = (struct gdb_bfd_data *) bfd_usrdata (includer);
868 gdata->included_bfds.push_back (new_bfd_ref (includee));
874 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
876 bfd *result = bfd_fdopenr (filename, target, fd);
878 return new_bfd_ref (result);
883 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
888 gdb_bfd_section_index (bfd *abfd, asection *section)
892 else if (section == bfd_com_section_ptr)
893 return bfd_count_sections (abfd);
894 else if (section == bfd_und_section_ptr)
895 return bfd_count_sections (abfd) + 1;
896 else if (section == bfd_abs_section_ptr)
897 return bfd_count_sections (abfd) + 2;
898 else if (section == bfd_ind_section_ptr)
899 return bfd_count_sections (abfd) + 3;
900 return section->index;
906 gdb_bfd_count_sections (bfd *abfd)
908 return bfd_count_sections (abfd) + 4;
914 gdb_bfd_requires_relocations (bfd *abfd)
916 struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
918 if (gdata->relocation_computed == 0)
922 for (sect = abfd->sections; sect != NULL; sect = sect->next)
923 if ((sect->flags & SEC_RELOC) != 0)
925 gdata->needs_relocations = 1;
929 gdata->relocation_computed = 1;
932 return gdata->needs_relocations;
937 /* A callback for htab_traverse that prints a single BFD. */
940 print_one_bfd (void **slot, void *data)
942 bfd *abfd = (struct bfd *) *slot;
943 struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
944 struct ui_out *uiout = (struct ui_out *) data;
946 ui_out_emit_tuple tuple_emitter (uiout, NULL);
947 uiout->field_int ("refcount", gdata->refc);
948 uiout->field_string ("addr", host_address_to_string (abfd));
949 uiout->field_string ("filename", bfd_get_filename (abfd));
955 /* Implement the 'maint info bfd' command. */
958 maintenance_info_bfds (const char *arg, int from_tty)
960 struct ui_out *uiout = current_uiout;
962 ui_out_emit_table table_emitter (uiout, 3, -1, "bfds");
963 uiout->table_header (10, ui_left, "refcount", "Refcount");
964 uiout->table_header (18, ui_left, "addr", "Address");
965 uiout->table_header (40, ui_left, "filename", "Filename");
967 uiout->table_body ();
968 htab_traverse (all_bfds, print_one_bfd, uiout);
972 _initialize_gdb_bfd (void)
974 all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
975 NULL, xcalloc, xfree);
977 add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
978 List the BFDs that are currently open."),
979 &maintenanceinfolist);
981 add_setshow_boolean_cmd ("bfd-sharing", no_class,
983 Set whether gdb will share bfds that appear to be the same file."), _("\
984 Show whether gdb will share bfds that appear to be the same file."), _("\
985 When enabled gdb will reuse existing bfds rather than reopening the\n\
986 same file. To decide if two files are the same then gdb compares the\n\
987 filename, file size, file modification time, and file inode."),
990 &maintenance_set_cmdlist,
991 &maintenance_show_cmdlist);
993 add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
994 &debug_bfd_cache, _("\
995 Set bfd cache debugging."), _("\
996 Show bfd cache debugging."), _("\
997 When non-zero, bfd cache specific debugging is enabled."),
999 &show_bfd_cache_debug,
1000 &setdebuglist, &showdebuglist);