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
;
526 gdata
= bfd_zalloc (abfd
, sizeof (struct gdb_bfd_data
));
528 gdata
->mtime
= bfd_get_mtime (abfd
);
529 gdata
->size
= bfd_get_size (abfd
);
530 gdata
->archive_bfd
= NULL
;
531 if (bfd_stat (abfd
, &buf
) == 0)
533 gdata
->inode
= buf
.st_ino
;
534 gdata
->device_id
= buf
.st_dev
;
538 /* The stat failed. */
540 gdata
->device_id
= 0;
542 bfd_usrdata (abfd
) = gdata
;
544 bfd_alloc_data (abfd
);
546 /* This is the first we've seen it, so add it to the hash table. */
547 slot
= htab_find_slot (all_bfds
, abfd
, INSERT
);
548 gdb_assert (slot
&& !*slot
);
555 gdb_bfd_unref (struct bfd
*abfd
)
558 struct gdb_bfd_data
*gdata
;
559 struct gdb_bfd_cache_search search
;
560 bfd
*archive_bfd
, *included_bfd
;
565 gdata
= bfd_usrdata (abfd
);
566 gdb_assert (gdata
->refc
>= 1);
572 fprintf_unfiltered (gdb_stdlog
,
573 "Decrease reference count on bfd %s (%s)\n",
574 host_address_to_string (abfd
),
575 bfd_get_filename (abfd
));
580 fprintf_unfiltered (gdb_stdlog
,
581 "Delete final reference count on bfd %s (%s)\n",
582 host_address_to_string (abfd
),
583 bfd_get_filename (abfd
));
585 archive_bfd
= gdata
->archive_bfd
;
586 search
.filename
= bfd_get_filename (abfd
);
588 if (gdb_bfd_cache
&& search
.filename
)
590 hashval_t hash
= htab_hash_string (search
.filename
);
593 search
.mtime
= gdata
->mtime
;
594 search
.size
= gdata
->size
;
595 search
.inode
= gdata
->inode
;
596 search
.device_id
= gdata
->device_id
;
597 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
,
601 htab_clear_slot (gdb_bfd_cache
, slot
);
605 VEC_iterate (bfdp
, gdata
->included_bfds
, ix
, included_bfd
);
607 gdb_bfd_unref (included_bfd
);
608 VEC_free (bfdp
, gdata
->included_bfds
);
610 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
= bfd_get_section_userdata (section
->owner
, section
);
633 result
= bfd_zalloc (section
->owner
, sizeof (*result
));
634 bfd_set_section_userdata (section
->owner
, section
, result
);
643 gdb_bfd_map_section (asection
*sectp
, bfd_size_type
*size
)
646 struct gdb_bfd_section_data
*descriptor
;
649 gdb_assert ((sectp
->flags
& SEC_RELOC
) == 0);
650 gdb_assert (size
!= NULL
);
654 descriptor
= get_section_descriptor (sectp
);
656 /* If the data was already read for this BFD, just reuse it. */
657 if (descriptor
->data
!= NULL
)
661 if (!bfd_is_section_compressed (abfd
, sectp
))
663 /* The page size, used when mmapping. */
667 pagesize
= getpagesize ();
669 /* Only try to mmap sections which are large enough: we don't want
670 to waste space due to fragmentation. */
672 if (bfd_get_section_size (sectp
) > 4 * pagesize
)
674 descriptor
->size
= bfd_get_section_size (sectp
);
675 descriptor
->data
= bfd_mmap (abfd
, 0, descriptor
->size
, PROT_READ
,
676 MAP_PRIVATE
, sectp
->filepos
,
677 &descriptor
->map_addr
,
678 &descriptor
->map_len
);
680 if ((caddr_t
)descriptor
->data
!= MAP_FAILED
)
682 #if HAVE_POSIX_MADVISE
683 posix_madvise (descriptor
->map_addr
, descriptor
->map_len
,
684 POSIX_MADV_WILLNEED
);
689 /* On failure, clear out the section data and try again. */
690 memset (descriptor
, 0, sizeof (*descriptor
));
693 #endif /* HAVE_MMAP */
695 /* Handle compressed sections, or ordinary uncompressed sections in
698 descriptor
->size
= bfd_get_section_size (sectp
);
699 descriptor
->data
= NULL
;
702 if (!bfd_get_full_section_contents (abfd
, sectp
, &data
))
703 error (_("Can't read data for section '%s' in file '%s'"),
704 bfd_get_section_name (abfd
, sectp
),
705 bfd_get_filename (abfd
));
706 descriptor
->data
= data
;
709 gdb_assert (descriptor
->data
!= NULL
);
710 *size
= descriptor
->size
;
711 return descriptor
->data
;
714 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
715 return 1. Otherwise print a warning and return 0. ABFD seek position is
719 get_file_crc (bfd
*abfd
, unsigned long *file_crc_return
)
721 unsigned long file_crc
= 0;
723 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
725 warning (_("Problem reading \"%s\" for CRC: %s"),
726 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
732 gdb_byte buffer
[8 * 1024];
735 count
= bfd_bread (buffer
, sizeof (buffer
), abfd
);
736 if (count
== (bfd_size_type
) -1)
738 warning (_("Problem reading \"%s\" for CRC: %s"),
739 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
744 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
747 *file_crc_return
= file_crc
;
754 gdb_bfd_crc (struct bfd
*abfd
, unsigned long *crc_out
)
756 struct gdb_bfd_data
*gdata
= bfd_usrdata (abfd
);
758 if (!gdata
->crc_computed
)
759 gdata
->crc_computed
= get_file_crc (abfd
, &gdata
->crc
);
761 if (gdata
->crc_computed
)
762 *crc_out
= gdata
->crc
;
763 return gdata
->crc_computed
;
771 gdb_bfd_fopen (const char *filename
, const char *target
, const char *mode
,
774 bfd
*result
= bfd_fopen (filename
, target
, mode
, fd
);
777 gdb_bfd_ref (result
);
785 gdb_bfd_openr (const char *filename
, const char *target
)
787 bfd
*result
= bfd_openr (filename
, target
);
790 gdb_bfd_ref (result
);
798 gdb_bfd_openw (const char *filename
, const char *target
)
800 bfd
*result
= bfd_openw (filename
, target
);
803 gdb_bfd_ref (result
);
811 gdb_bfd_openr_iovec (const char *filename
, const char *target
,
812 void *(*open_func
) (struct bfd
*nbfd
,
815 file_ptr (*pread_func
) (struct bfd
*nbfd
,
820 int (*close_func
) (struct bfd
*nbfd
,
822 int (*stat_func
) (struct bfd
*abfd
,
826 bfd
*result
= bfd_openr_iovec (filename
, target
,
827 open_func
, open_closure
,
828 pread_func
, close_func
, stat_func
);
831 gdb_bfd_ref (result
);
839 gdb_bfd_mark_parent (bfd
*child
, bfd
*parent
)
841 struct gdb_bfd_data
*gdata
;
844 /* No need to stash the filename here, because we also keep a
845 reference on the parent archive. */
847 gdata
= bfd_usrdata (child
);
848 if (gdata
->archive_bfd
== NULL
)
850 gdata
->archive_bfd
= parent
;
851 gdb_bfd_ref (parent
);
854 gdb_assert (gdata
->archive_bfd
== parent
);
860 gdb_bfd_openr_next_archived_file (bfd
*archive
, bfd
*previous
)
862 bfd
*result
= bfd_openr_next_archived_file (archive
, previous
);
865 gdb_bfd_mark_parent (result
, archive
);
873 gdb_bfd_record_inclusion (bfd
*includer
, bfd
*includee
)
875 struct gdb_bfd_data
*gdata
;
877 gdb_bfd_ref (includee
);
878 gdata
= bfd_usrdata (includer
);
879 VEC_safe_push (bfdp
, gdata
->included_bfds
, includee
);
885 gdb_bfd_fdopenr (const char *filename
, const char *target
, int fd
)
887 bfd
*result
= bfd_fdopenr (filename
, target
, fd
);
890 gdb_bfd_ref (result
);
897 gdb_static_assert (ARRAY_SIZE (_bfd_std_section
) == 4);
902 gdb_bfd_section_index (bfd
*abfd
, asection
*section
)
906 else if (section
== bfd_com_section_ptr
)
907 return bfd_count_sections (abfd
);
908 else if (section
== bfd_und_section_ptr
)
909 return bfd_count_sections (abfd
) + 1;
910 else if (section
== bfd_abs_section_ptr
)
911 return bfd_count_sections (abfd
) + 2;
912 else if (section
== bfd_ind_section_ptr
)
913 return bfd_count_sections (abfd
) + 3;
914 return section
->index
;
920 gdb_bfd_count_sections (bfd
*abfd
)
922 return bfd_count_sections (abfd
) + 4;
928 gdb_bfd_requires_relocations (bfd
*abfd
)
930 struct gdb_bfd_data
*gdata
= bfd_usrdata (abfd
);
932 if (gdata
->relocation_computed
== 0)
936 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
937 if ((sect
->flags
& SEC_RELOC
) != 0)
939 gdata
->needs_relocations
= 1;
943 gdata
->relocation_computed
= 1;
946 return gdata
->needs_relocations
;
951 /* A callback for htab_traverse that prints a single BFD. */
954 print_one_bfd (void **slot
, void *data
)
957 struct gdb_bfd_data
*gdata
= bfd_usrdata (abfd
);
958 struct ui_out
*uiout
= data
;
959 struct cleanup
*inner
;
961 inner
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
962 ui_out_field_int (uiout
, "refcount", gdata
->refc
);
963 ui_out_field_string (uiout
, "addr", host_address_to_string (abfd
));
964 ui_out_field_string (uiout
, "filename", bfd_get_filename (abfd
));
965 ui_out_text (uiout
, "\n");
971 /* Implement the 'maint info bfd' command. */
974 maintenance_info_bfds (char *arg
, int from_tty
)
976 struct cleanup
*cleanup
;
977 struct ui_out
*uiout
= current_uiout
;
979 cleanup
= make_cleanup_ui_out_table_begin_end (uiout
, 3, -1, "bfds");
980 ui_out_table_header (uiout
, 10, ui_left
, "refcount", "Refcount");
981 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
982 ui_out_table_header (uiout
, 40, ui_left
, "filename", "Filename");
984 ui_out_table_body (uiout
);
985 htab_traverse (all_bfds
, print_one_bfd
, uiout
);
987 do_cleanups (cleanup
);
990 /* -Wmissing-prototypes */
991 extern initialize_file_ftype _initialize_gdb_bfd
;
994 _initialize_gdb_bfd (void)
996 all_bfds
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
997 NULL
, xcalloc
, xfree
);
999 add_cmd ("bfds", class_maintenance
, maintenance_info_bfds
, _("\
1000 List the BFDs that are currently open."),
1001 &maintenanceinfolist
);
1003 add_setshow_boolean_cmd ("bfd-sharing", no_class
,
1005 Set whether gdb will share bfds that appear to be the same file."), _("\
1006 Show whether gdb will share bfds that appear to be the same file."), _("\
1007 When enabled gdb will reuse existing bfds rather than reopening the\n\
1008 same file. To decide if two files are the same then gdb compares the\n\
1009 filename, file size, file modification time, and file inode."),
1012 &maintenance_set_cmdlist
,
1013 &maintenance_show_cmdlist
);
1015 add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance
,
1016 &debug_bfd_cache
, _("\
1017 Set bfd cache debugging."), _("\
1018 Show bfd cache debugging."), _("\
1019 When non-zero, bfd cache specific debugging is enabled."),
1021 &show_bfd_cache_debug
,
1022 &setdebuglist
, &showdebuglist
);