1 /* Definitions for BFD wrappers used by GDB.
3 Copyright (C) 2011-2020 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 "gdbsupport/filestuff.h"
29 #define MAP_FAILED ((void *) -1)
33 #include "gdb/fileio.h"
36 /* An object of this type is stored in the section's user data when
39 struct gdb_bfd_section_data
41 /* Size of the data. */
43 /* If the data was mmapped, this is the length of the map. */
44 bfd_size_type map_len
;
45 /* The data. If NULL, the section data has not been read. */
47 /* If the data was mmapped, this is the map address. */
51 /* A hash table holding every BFD that gdb knows about. This is not
52 to be confused with 'gdb_bfd_cache', which is used for sharing
53 BFDs; in contrast, this hash is used just to implement
56 static htab_t all_bfds
;
58 /* An object of this type is stored in each BFD's user data. */
62 gdb_bfd_data (bfd
*abfd
)
63 : mtime (bfd_get_mtime (abfd
)),
64 size (bfd_get_size (abfd
)),
65 relocation_computed (0),
66 needs_relocations (0),
71 if (bfd_stat (abfd
, &buf
) == 0)
74 device_id
= buf
.st_dev
;
78 /* The stat failed. */
88 /* The reference count. */
91 /* The mtime of the BFD at the point the cache entry was made. */
94 /* The file size (in bytes) at the point the cache entry was made. */
97 /* The inode of the file at the point the cache entry was made. */
100 /* The device id of the file at the point the cache entry was made. */
103 /* This is true if we have determined whether this BFD has any
104 sections requiring relocation. */
105 unsigned int relocation_computed
: 1;
107 /* This is true if any section needs relocation. */
108 unsigned int needs_relocations
: 1;
110 /* This is true if we have successfully computed the file's CRC. */
111 unsigned int crc_computed
: 1;
113 /* The file's CRC. */
114 unsigned long crc
= 0;
116 /* If the BFD comes from an archive, this points to the archive's
117 BFD. Otherwise, this is NULL. */
118 bfd
*archive_bfd
= nullptr;
120 /* Table of all the bfds this bfd has included. */
121 std::vector
<gdb_bfd_ref_ptr
> included_bfds
;
124 REGISTRY_FIELDS
= {};
127 #define GDB_BFD_DATA_ACCESSOR(ABFD) \
128 ((struct gdb_bfd_data *) bfd_usrdata (ABFD))
130 DEFINE_REGISTRY (bfd
, GDB_BFD_DATA_ACCESSOR
)
132 /* A hash table storing all the BFDs maintained in the cache. */
134 static htab_t gdb_bfd_cache
;
136 /* When true gdb will reuse an existing bfd object if the filename,
137 modification time, and file size all match. */
139 static bool bfd_sharing
= true;
141 show_bfd_sharing (struct ui_file
*file
, int from_tty
,
142 struct cmd_list_element
*c
, const char *value
)
144 fprintf_filtered (file
, _("BFD sharing is %s.\n"), value
);
147 /* When non-zero debugging of the bfd caches is enabled. */
149 static unsigned int debug_bfd_cache
;
151 show_bfd_cache_debug (struct ui_file
*file
, int from_tty
,
152 struct cmd_list_element
*c
, const char *value
)
154 fprintf_filtered (file
, _("BFD cache debugging is %s.\n"), value
);
157 /* The type of an object being looked up in gdb_bfd_cache. We use
158 htab's capability of storing one kind of object (BFD in this case)
159 and using a different sort of object for searching. */
161 struct gdb_bfd_cache_search
164 const char *filename
;
167 /* The file size (in bytes). */
169 /* The inode of the file. */
171 /* The device id of the file. */
175 /* A hash function for BFDs. */
178 hash_bfd (const void *b
)
180 const bfd
*abfd
= (const struct bfd
*) b
;
182 /* It is simplest to just hash the filename. */
183 return htab_hash_string (bfd_get_filename (abfd
));
186 /* An equality function for BFDs. Note that this expects the caller
187 to search using struct gdb_bfd_cache_search only, not BFDs. */
190 eq_bfd (const void *a
, const void *b
)
192 const bfd
*abfd
= (const struct bfd
*) a
;
193 const struct gdb_bfd_cache_search
*s
194 = (const struct gdb_bfd_cache_search
*) b
;
195 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
197 return (gdata
->mtime
== s
->mtime
198 && gdata
->size
== s
->size
199 && gdata
->inode
== s
->inode
200 && gdata
->device_id
== s
->device_id
201 && strcmp (bfd_get_filename (abfd
), s
->filename
) == 0);
207 is_target_filename (const char *name
)
209 return startswith (name
, TARGET_SYSROOT_PREFIX
);
215 gdb_bfd_has_target_filename (struct bfd
*abfd
)
217 return is_target_filename (bfd_get_filename (abfd
));
221 /* Return the system error number corresponding to ERRNUM. */
224 fileio_errno_to_host (int errnum
)
268 case FILEIO_ENAMETOOLONG
:
274 /* bfd_openr_iovec OPEN_CLOSURE data for gdb_bfd_open. */
275 struct gdb_bfd_open_closure
281 /* Wrapper for target_fileio_open suitable for passing as the
282 OPEN_FUNC argument to gdb_bfd_openr_iovec. */
285 gdb_bfd_iovec_fileio_open (struct bfd
*abfd
, void *open_closure
)
287 const char *filename
= bfd_get_filename (abfd
);
288 int fd
, target_errno
;
290 gdb_bfd_open_closure
*oclosure
= (gdb_bfd_open_closure
*) open_closure
;
292 gdb_assert (is_target_filename (filename
));
294 fd
= target_fileio_open (oclosure
->inf
,
295 filename
+ strlen (TARGET_SYSROOT_PREFIX
),
296 FILEIO_O_RDONLY
, 0, oclosure
->warn_if_slow
,
300 errno
= fileio_errno_to_host (target_errno
);
301 bfd_set_error (bfd_error_system_call
);
305 stream
= XCNEW (int);
310 /* Wrapper for target_fileio_pread suitable for passing as the
311 PREAD_FUNC argument to gdb_bfd_openr_iovec. */
314 gdb_bfd_iovec_fileio_pread (struct bfd
*abfd
, void *stream
, void *buf
,
315 file_ptr nbytes
, file_ptr offset
)
317 int fd
= *(int *) stream
;
326 bytes
= target_fileio_pread (fd
, (gdb_byte
*) buf
+ pos
,
327 nbytes
- pos
, offset
+ pos
,
330 /* Success, but no bytes, means end-of-file. */
334 errno
= fileio_errno_to_host (target_errno
);
335 bfd_set_error (bfd_error_system_call
);
345 /* Wrapper for target_fileio_close suitable for passing as the
346 CLOSE_FUNC argument to gdb_bfd_openr_iovec. */
349 gdb_bfd_iovec_fileio_close (struct bfd
*abfd
, void *stream
)
351 int fd
= *(int *) stream
;
356 /* Ignore errors on close. These may happen with remote
357 targets if the connection has already been torn down. */
358 target_fileio_close (fd
, &target_errno
);
360 /* Zero means success. */
364 /* Wrapper for target_fileio_fstat suitable for passing as the
365 STAT_FUNC argument to gdb_bfd_openr_iovec. */
368 gdb_bfd_iovec_fileio_fstat (struct bfd
*abfd
, void *stream
,
371 int fd
= *(int *) stream
;
375 result
= target_fileio_fstat (fd
, sb
, &target_errno
);
378 errno
= fileio_errno_to_host (target_errno
);
379 bfd_set_error (bfd_error_system_call
);
388 gdb_bfd_open (const char *name
, const char *target
, int fd
,
394 struct gdb_bfd_cache_search search
;
397 if (is_target_filename (name
))
399 if (!target_filesystem_is_local ())
401 gdb_assert (fd
== -1);
403 gdb_bfd_open_closure open_closure
{ current_inferior (), warn_if_slow
};
404 return gdb_bfd_openr_iovec (name
, target
,
405 gdb_bfd_iovec_fileio_open
,
407 gdb_bfd_iovec_fileio_pread
,
408 gdb_bfd_iovec_fileio_close
,
409 gdb_bfd_iovec_fileio_fstat
);
412 name
+= strlen (TARGET_SYSROOT_PREFIX
);
415 if (gdb_bfd_cache
== NULL
)
416 gdb_bfd_cache
= htab_create_alloc (1, hash_bfd
, eq_bfd
, NULL
,
421 fd
= gdb_open_cloexec (name
, O_RDONLY
| O_BINARY
, 0);
424 bfd_set_error (bfd_error_system_call
);
429 search
.filename
= name
;
430 if (fstat (fd
, &st
) < 0)
432 /* Weird situation here. */
436 search
.device_id
= 0;
440 search
.mtime
= st
.st_mtime
;
441 search
.size
= st
.st_size
;
442 search
.inode
= st
.st_ino
;
443 search
.device_id
= st
.st_dev
;
446 /* Note that this must compute the same result as hash_bfd. */
447 hash
= htab_hash_string (name
);
448 /* Note that we cannot use htab_find_slot_with_hash here, because
449 opening the BFD may fail; and this would violate hashtab
451 abfd
= (struct bfd
*) htab_find_with_hash (gdb_bfd_cache
, &search
, hash
);
452 if (bfd_sharing
&& abfd
!= NULL
)
455 fprintf_unfiltered (gdb_stdlog
,
456 "Reusing cached bfd %s for %s\n",
457 host_address_to_string (abfd
),
458 bfd_get_filename (abfd
));
460 return gdb_bfd_ref_ptr::new_reference (abfd
);
463 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
468 fprintf_unfiltered (gdb_stdlog
,
469 "Creating new bfd %s for %s\n",
470 host_address_to_string (abfd
),
471 bfd_get_filename (abfd
));
475 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
, INSERT
);
480 return gdb_bfd_ref_ptr::new_reference (abfd
);
483 /* A helper function that releases any section data attached to the
487 free_one_bfd_section (bfd
*abfd
, asection
*sectp
, void *ignore
)
489 struct gdb_bfd_section_data
*sect
490 = (struct gdb_bfd_section_data
*) bfd_section_userdata (sectp
);
492 if (sect
!= NULL
&& sect
->data
!= NULL
)
495 if (sect
->map_addr
!= NULL
)
499 res
= munmap (sect
->map_addr
, sect
->map_len
);
500 gdb_assert (res
== 0);
508 /* Close ABFD, and warn if that fails. */
511 gdb_bfd_close_or_warn (struct bfd
*abfd
)
514 const char *name
= bfd_get_filename (abfd
);
516 bfd_map_over_sections (abfd
, free_one_bfd_section
, NULL
);
518 ret
= bfd_close (abfd
);
521 warning (_("cannot close \"%s\": %s"),
522 name
, bfd_errmsg (bfd_get_error ()));
530 gdb_bfd_ref (struct bfd
*abfd
)
532 struct gdb_bfd_data
*gdata
;
538 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
541 fprintf_unfiltered (gdb_stdlog
,
542 "Increase reference count on bfd %s (%s)\n",
543 host_address_to_string (abfd
),
544 bfd_get_filename (abfd
));
552 /* Ask BFD to decompress sections in bfd_get_full_section_contents. */
553 abfd
->flags
|= BFD_DECOMPRESS
;
555 gdata
= new gdb_bfd_data (abfd
);
556 bfd_set_usrdata (abfd
, gdata
);
557 bfd_alloc_data (abfd
);
559 /* This is the first we've seen it, so add it to the hash table. */
560 slot
= htab_find_slot (all_bfds
, abfd
, INSERT
);
561 gdb_assert (slot
&& !*slot
);
568 gdb_bfd_unref (struct bfd
*abfd
)
570 struct gdb_bfd_data
*gdata
;
571 struct gdb_bfd_cache_search search
;
577 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
578 gdb_assert (gdata
->refc
>= 1);
584 fprintf_unfiltered (gdb_stdlog
,
585 "Decrease reference count on bfd %s (%s)\n",
586 host_address_to_string (abfd
),
587 bfd_get_filename (abfd
));
592 fprintf_unfiltered (gdb_stdlog
,
593 "Delete final reference count on bfd %s (%s)\n",
594 host_address_to_string (abfd
),
595 bfd_get_filename (abfd
));
597 archive_bfd
= gdata
->archive_bfd
;
598 search
.filename
= bfd_get_filename (abfd
);
600 if (gdb_bfd_cache
&& search
.filename
)
602 hashval_t hash
= htab_hash_string (search
.filename
);
605 search
.mtime
= gdata
->mtime
;
606 search
.size
= gdata
->size
;
607 search
.inode
= gdata
->inode
;
608 search
.device_id
= gdata
->device_id
;
609 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
,
613 htab_clear_slot (gdb_bfd_cache
, slot
);
616 bfd_free_data (abfd
);
618 bfd_set_usrdata (abfd
, NULL
); /* Paranoia. */
620 htab_remove_elt (all_bfds
, abfd
);
622 gdb_bfd_close_or_warn (abfd
);
624 gdb_bfd_unref (archive_bfd
);
627 /* A helper function that returns the section data descriptor
628 associated with SECTION. If no such descriptor exists, a new one
629 is allocated and cleared. */
631 static struct gdb_bfd_section_data
*
632 get_section_descriptor (asection
*section
)
634 struct gdb_bfd_section_data
*result
;
636 result
= (struct gdb_bfd_section_data
*) bfd_section_userdata (section
);
640 result
= ((struct gdb_bfd_section_data
*)
641 bfd_zalloc (section
->owner
, sizeof (*result
)));
642 bfd_set_section_userdata (section
, result
);
651 gdb_bfd_map_section (asection
*sectp
, bfd_size_type
*size
)
654 struct gdb_bfd_section_data
*descriptor
;
657 gdb_assert ((sectp
->flags
& SEC_RELOC
) == 0);
658 gdb_assert (size
!= NULL
);
662 descriptor
= get_section_descriptor (sectp
);
664 /* If the data was already read for this BFD, just reuse it. */
665 if (descriptor
->data
!= NULL
)
669 if (!bfd_is_section_compressed (abfd
, sectp
))
671 /* The page size, used when mmapping. */
675 pagesize
= getpagesize ();
677 /* Only try to mmap sections which are large enough: we don't want
678 to waste space due to fragmentation. */
680 if (bfd_section_size (sectp
) > 4 * pagesize
)
682 descriptor
->size
= bfd_section_size (sectp
);
683 descriptor
->data
= bfd_mmap (abfd
, 0, descriptor
->size
, PROT_READ
,
684 MAP_PRIVATE
, sectp
->filepos
,
685 &descriptor
->map_addr
,
686 &descriptor
->map_len
);
688 if ((caddr_t
)descriptor
->data
!= MAP_FAILED
)
690 #if HAVE_POSIX_MADVISE
691 posix_madvise (descriptor
->map_addr
, descriptor
->map_len
,
692 POSIX_MADV_WILLNEED
);
697 /* On failure, clear out the section data and try again. */
698 memset (descriptor
, 0, sizeof (*descriptor
));
701 #endif /* HAVE_MMAP */
703 /* Handle compressed sections, or ordinary uncompressed sections in
706 descriptor
->size
= bfd_section_size (sectp
);
707 descriptor
->data
= NULL
;
710 if (!bfd_get_full_section_contents (abfd
, sectp
, &data
))
712 warning (_("Can't read data for section '%s' in file '%s'"),
713 bfd_section_name (sectp
),
714 bfd_get_filename (abfd
));
715 /* Set size to 0 to prevent further attempts to read the invalid
720 descriptor
->data
= data
;
723 gdb_assert (descriptor
->data
!= NULL
);
724 *size
= descriptor
->size
;
725 return (const gdb_byte
*) descriptor
->data
;
728 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
729 return 1. Otherwise print a warning and return 0. ABFD seek position is
733 get_file_crc (bfd
*abfd
, unsigned long *file_crc_return
)
735 unsigned long file_crc
= 0;
737 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
739 warning (_("Problem reading \"%s\" for CRC: %s"),
740 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
746 gdb_byte buffer
[8 * 1024];
749 count
= bfd_bread (buffer
, sizeof (buffer
), abfd
);
750 if (count
== (bfd_size_type
) -1)
752 warning (_("Problem reading \"%s\" for CRC: %s"),
753 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
758 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
761 *file_crc_return
= file_crc
;
768 gdb_bfd_crc (struct bfd
*abfd
, unsigned long *crc_out
)
770 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
772 if (!gdata
->crc_computed
)
773 gdata
->crc_computed
= get_file_crc (abfd
, &gdata
->crc
);
775 if (gdata
->crc_computed
)
776 *crc_out
= gdata
->crc
;
777 return gdata
->crc_computed
;
785 gdb_bfd_fopen (const char *filename
, const char *target
, const char *mode
,
788 bfd
*result
= bfd_fopen (filename
, target
, mode
, fd
);
790 return gdb_bfd_ref_ptr::new_reference (result
);
796 gdb_bfd_openr (const char *filename
, const char *target
)
798 bfd
*result
= bfd_openr (filename
, target
);
800 return gdb_bfd_ref_ptr::new_reference (result
);
806 gdb_bfd_openw (const char *filename
, const char *target
)
808 bfd
*result
= bfd_openw (filename
, target
);
810 return gdb_bfd_ref_ptr::new_reference (result
);
816 gdb_bfd_openr_iovec (const char *filename
, const char *target
,
817 void *(*open_func
) (struct bfd
*nbfd
,
820 file_ptr (*pread_func
) (struct bfd
*nbfd
,
825 int (*close_func
) (struct bfd
*nbfd
,
827 int (*stat_func
) (struct bfd
*abfd
,
831 bfd
*result
= bfd_openr_iovec (filename
, target
,
832 open_func
, open_closure
,
833 pread_func
, close_func
, stat_func
);
835 return gdb_bfd_ref_ptr::new_reference (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
= (struct gdb_bfd_data
*) 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
);
869 return gdb_bfd_ref_ptr (result
);
875 gdb_bfd_record_inclusion (bfd
*includer
, bfd
*includee
)
877 struct gdb_bfd_data
*gdata
;
879 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (includer
);
880 gdata
->included_bfds
.push_back (gdb_bfd_ref_ptr::new_reference (includee
));
885 gdb_static_assert (ARRAY_SIZE (_bfd_std_section
) == 4);
890 gdb_bfd_section_index (bfd
*abfd
, asection
*section
)
894 else if (section
== bfd_com_section_ptr
)
895 return bfd_count_sections (abfd
);
896 else if (section
== bfd_und_section_ptr
)
897 return bfd_count_sections (abfd
) + 1;
898 else if (section
== bfd_abs_section_ptr
)
899 return bfd_count_sections (abfd
) + 2;
900 else if (section
== bfd_ind_section_ptr
)
901 return bfd_count_sections (abfd
) + 3;
902 return section
->index
;
908 gdb_bfd_count_sections (bfd
*abfd
)
910 return bfd_count_sections (abfd
) + 4;
916 gdb_bfd_requires_relocations (bfd
*abfd
)
918 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
920 if (gdata
->relocation_computed
== 0)
924 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
925 if ((sect
->flags
& SEC_RELOC
) != 0)
927 gdata
->needs_relocations
= 1;
931 gdata
->relocation_computed
= 1;
934 return gdata
->needs_relocations
;
940 gdb_bfd_get_full_section_contents (bfd
*abfd
, asection
*section
,
941 gdb::byte_vector
*contents
)
943 bfd_size_type section_size
= bfd_section_size (section
);
945 contents
->resize (section_size
);
947 return bfd_get_section_contents (abfd
, section
, contents
->data (), 0,
951 /* A callback for htab_traverse that prints a single BFD. */
954 print_one_bfd (void **slot
, void *data
)
956 bfd
*abfd
= (struct bfd
*) *slot
;
957 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
958 struct ui_out
*uiout
= (struct ui_out
*) data
;
960 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
961 uiout
->field_signed ("refcount", gdata
->refc
);
962 uiout
->field_string ("addr", host_address_to_string (abfd
));
963 uiout
->field_string ("filename", bfd_get_filename (abfd
));
969 /* Implement the 'maint info bfd' command. */
972 maintenance_info_bfds (const char *arg
, int from_tty
)
974 struct ui_out
*uiout
= current_uiout
;
976 ui_out_emit_table
table_emitter (uiout
, 3, -1, "bfds");
977 uiout
->table_header (10, ui_left
, "refcount", "Refcount");
978 uiout
->table_header (18, ui_left
, "addr", "Address");
979 uiout
->table_header (40, ui_left
, "filename", "Filename");
981 uiout
->table_body ();
982 htab_traverse (all_bfds
, print_one_bfd
, uiout
);
985 void _initialize_gdb_bfd ();
987 _initialize_gdb_bfd ()
989 all_bfds
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
990 NULL
, xcalloc
, xfree
);
992 add_cmd ("bfds", class_maintenance
, maintenance_info_bfds
, _("\
993 List the BFDs that are currently open."),
994 &maintenanceinfolist
);
996 add_setshow_boolean_cmd ("bfd-sharing", no_class
,
998 Set whether gdb will share bfds that appear to be the same file."), _("\
999 Show whether gdb will share bfds that appear to be the same file."), _("\
1000 When enabled gdb will reuse existing bfds rather than reopening the\n\
1001 same file. To decide if two files are the same then gdb compares the\n\
1002 filename, file size, file modification time, and file inode."),
1005 &maintenance_set_cmdlist
,
1006 &maintenance_show_cmdlist
);
1008 add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance
,
1009 &debug_bfd_cache
, _("\
1010 Set bfd cache debugging."), _("\
1011 Show bfd cache debugging."), _("\
1012 When non-zero, bfd cache specific debugging is enabled."),
1014 &show_bfd_cache_debug
,
1015 &setdebuglist
, &showdebuglist
);