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 /* The type of an object being looked up in gdb_bfd_cache. We use
126 htab's capability of storing one kind of object (BFD in this case)
127 and using a different sort of object for searching. */
129 struct gdb_bfd_cache_search
132 const char *filename
;
135 /* The file size (in bytes). */
137 /* The inode of the file. */
139 /* The device id of the file. */
143 /* A hash function for BFDs. */
146 hash_bfd (const void *b
)
150 /* It is simplest to just hash the filename. */
151 return htab_hash_string (bfd_get_filename (abfd
));
154 /* An equality function for BFDs. Note that this expects the caller
155 to search using struct gdb_bfd_cache_search only, not BFDs. */
158 eq_bfd (const void *a
, const void *b
)
161 const struct gdb_bfd_cache_search
*s
= b
;
162 struct gdb_bfd_data
*gdata
= bfd_usrdata (abfd
);
164 return (gdata
->mtime
== s
->mtime
165 && gdata
->size
== s
->size
166 && gdata
->inode
== s
->inode
167 && gdata
->device_id
== s
->device_id
168 && strcmp (bfd_get_filename (abfd
), s
->filename
) == 0);
174 is_target_filename (const char *name
)
176 return startswith (name
, TARGET_SYSROOT_PREFIX
);
182 gdb_bfd_has_target_filename (struct bfd
*abfd
)
184 return is_target_filename (bfd_get_filename (abfd
));
188 /* Return the system error number corresponding to ERRNUM. */
191 fileio_errno_to_host (int errnum
)
235 case FILEIO_ENAMETOOLONG
:
241 /* Wrapper for target_fileio_open suitable for passing as the
242 OPEN_FUNC argument to gdb_bfd_openr_iovec. The supplied
243 OPEN_CLOSURE is unused. */
246 gdb_bfd_iovec_fileio_open (struct bfd
*abfd
, void *inferior
)
248 const char *filename
= bfd_get_filename (abfd
);
249 int fd
, target_errno
;
252 gdb_assert (is_target_filename (filename
));
254 fd
= target_fileio_open ((struct inferior
*) inferior
,
255 filename
+ strlen (TARGET_SYSROOT_PREFIX
),
260 errno
= fileio_errno_to_host (target_errno
);
261 bfd_set_error (bfd_error_system_call
);
265 stream
= XCNEW (int);
270 /* Wrapper for target_fileio_pread suitable for passing as the
271 PREAD_FUNC argument to gdb_bfd_openr_iovec. */
274 gdb_bfd_iovec_fileio_pread (struct bfd
*abfd
, void *stream
, void *buf
,
275 file_ptr nbytes
, file_ptr offset
)
277 int fd
= *(int *) stream
;
284 bytes
= target_fileio_pread (fd
, (gdb_byte
*) buf
+ pos
,
285 nbytes
- pos
, offset
+ pos
,
288 /* Success, but no bytes, means end-of-file. */
292 errno
= fileio_errno_to_host (target_errno
);
293 bfd_set_error (bfd_error_system_call
);
303 /* Wrapper for target_fileio_close suitable for passing as the
304 CLOSE_FUNC argument to gdb_bfd_openr_iovec. */
307 gdb_bfd_iovec_fileio_close (struct bfd
*abfd
, void *stream
)
309 int fd
= *(int *) stream
;
314 /* Ignore errors on close. These may happen with remote
315 targets if the connection has already been torn down. */
316 target_fileio_close (fd
, &target_errno
);
318 /* Zero means success. */
322 /* Wrapper for target_fileio_fstat suitable for passing as the
323 STAT_FUNC argument to gdb_bfd_openr_iovec. */
326 gdb_bfd_iovec_fileio_fstat (struct bfd
*abfd
, void *stream
,
329 int fd
= *(int *) stream
;
333 result
= target_fileio_fstat (fd
, sb
, &target_errno
);
336 errno
= fileio_errno_to_host (target_errno
);
337 bfd_set_error (bfd_error_system_call
);
346 gdb_bfd_open (const char *name
, const char *target
, int fd
)
351 struct gdb_bfd_cache_search search
;
354 if (is_target_filename (name
))
356 if (!target_filesystem_is_local ())
358 gdb_assert (fd
== -1);
360 return gdb_bfd_openr_iovec (name
, target
,
361 gdb_bfd_iovec_fileio_open
,
363 gdb_bfd_iovec_fileio_pread
,
364 gdb_bfd_iovec_fileio_close
,
365 gdb_bfd_iovec_fileio_fstat
);
368 name
+= strlen (TARGET_SYSROOT_PREFIX
);
371 if (gdb_bfd_cache
== NULL
)
372 gdb_bfd_cache
= htab_create_alloc (1, hash_bfd
, eq_bfd
, NULL
,
377 fd
= gdb_open_cloexec (name
, O_RDONLY
| O_BINARY
, 0);
380 bfd_set_error (bfd_error_system_call
);
385 search
.filename
= name
;
386 if (fstat (fd
, &st
) < 0)
388 /* Weird situation here. */
392 search
.device_id
= 0;
396 search
.mtime
= st
.st_mtime
;
397 search
.size
= st
.st_size
;
398 search
.inode
= st
.st_ino
;
399 search
.device_id
= st
.st_dev
;
402 /* Note that this must compute the same result as hash_bfd. */
403 hash
= htab_hash_string (name
);
404 /* Note that we cannot use htab_find_slot_with_hash here, because
405 opening the BFD may fail; and this would violate hashtab
407 abfd
= htab_find_with_hash (gdb_bfd_cache
, &search
, hash
);
408 if (bfd_sharing
&& abfd
!= NULL
)
415 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
421 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
, INSERT
);
430 /* A helper function that releases any section data attached to the
434 free_one_bfd_section (bfd
*abfd
, asection
*sectp
, void *ignore
)
436 struct gdb_bfd_section_data
*sect
= bfd_get_section_userdata (abfd
, sectp
);
438 if (sect
!= NULL
&& sect
->data
!= NULL
)
441 if (sect
->map_addr
!= NULL
)
445 res
= munmap (sect
->map_addr
, sect
->map_len
);
446 gdb_assert (res
== 0);
454 /* Close ABFD, and warn if that fails. */
457 gdb_bfd_close_or_warn (struct bfd
*abfd
)
460 char *name
= bfd_get_filename (abfd
);
462 bfd_map_over_sections (abfd
, free_one_bfd_section
, NULL
);
464 ret
= bfd_close (abfd
);
467 warning (_("cannot close \"%s\": %s"),
468 name
, bfd_errmsg (bfd_get_error ()));
476 gdb_bfd_ref (struct bfd
*abfd
)
479 struct gdb_bfd_data
*gdata
;
485 gdata
= bfd_usrdata (abfd
);
493 /* Ask BFD to decompress sections in bfd_get_full_section_contents. */
494 abfd
->flags
|= BFD_DECOMPRESS
;
496 gdata
= bfd_zalloc (abfd
, sizeof (struct gdb_bfd_data
));
498 gdata
->mtime
= bfd_get_mtime (abfd
);
499 gdata
->size
= bfd_get_size (abfd
);
500 gdata
->archive_bfd
= NULL
;
501 if (bfd_stat (abfd
, &buf
) == 0)
503 gdata
->inode
= buf
.st_ino
;
504 gdata
->device_id
= buf
.st_dev
;
508 /* The stat failed. */
510 gdata
->device_id
= 0;
512 bfd_usrdata (abfd
) = gdata
;
514 bfd_alloc_data (abfd
);
516 /* This is the first we've seen it, so add it to the hash table. */
517 slot
= htab_find_slot (all_bfds
, abfd
, INSERT
);
518 gdb_assert (slot
&& !*slot
);
525 gdb_bfd_unref (struct bfd
*abfd
)
528 struct gdb_bfd_data
*gdata
;
529 struct gdb_bfd_cache_search search
;
530 bfd
*archive_bfd
, *included_bfd
;
535 gdata
= bfd_usrdata (abfd
);
536 gdb_assert (gdata
->refc
>= 1);
542 archive_bfd
= gdata
->archive_bfd
;
543 search
.filename
= bfd_get_filename (abfd
);
545 if (gdb_bfd_cache
&& search
.filename
)
547 hashval_t hash
= htab_hash_string (search
.filename
);
550 search
.mtime
= gdata
->mtime
;
551 search
.size
= gdata
->size
;
552 search
.inode
= gdata
->inode
;
553 search
.device_id
= gdata
->device_id
;
554 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
,
558 htab_clear_slot (gdb_bfd_cache
, slot
);
562 VEC_iterate (bfdp
, gdata
->included_bfds
, ix
, included_bfd
);
564 gdb_bfd_unref (included_bfd
);
565 VEC_free (bfdp
, gdata
->included_bfds
);
567 bfd_free_data (abfd
);
568 bfd_usrdata (abfd
) = NULL
; /* Paranoia. */
570 htab_remove_elt (all_bfds
, abfd
);
572 gdb_bfd_close_or_warn (abfd
);
574 gdb_bfd_unref (archive_bfd
);
577 /* A helper function that returns the section data descriptor
578 associated with SECTION. If no such descriptor exists, a new one
579 is allocated and cleared. */
581 static struct gdb_bfd_section_data
*
582 get_section_descriptor (asection
*section
)
584 struct gdb_bfd_section_data
*result
;
586 result
= bfd_get_section_userdata (section
->owner
, section
);
590 result
= bfd_zalloc (section
->owner
, sizeof (*result
));
591 bfd_set_section_userdata (section
->owner
, section
, result
);
600 gdb_bfd_map_section (asection
*sectp
, bfd_size_type
*size
)
603 struct gdb_bfd_section_data
*descriptor
;
606 gdb_assert ((sectp
->flags
& SEC_RELOC
) == 0);
607 gdb_assert (size
!= NULL
);
611 descriptor
= get_section_descriptor (sectp
);
613 /* If the data was already read for this BFD, just reuse it. */
614 if (descriptor
->data
!= NULL
)
618 if (!bfd_is_section_compressed (abfd
, sectp
))
620 /* The page size, used when mmapping. */
624 pagesize
= getpagesize ();
626 /* Only try to mmap sections which are large enough: we don't want
627 to waste space due to fragmentation. */
629 if (bfd_get_section_size (sectp
) > 4 * pagesize
)
631 descriptor
->size
= bfd_get_section_size (sectp
);
632 descriptor
->data
= bfd_mmap (abfd
, 0, descriptor
->size
, PROT_READ
,
633 MAP_PRIVATE
, sectp
->filepos
,
634 &descriptor
->map_addr
,
635 &descriptor
->map_len
);
637 if ((caddr_t
)descriptor
->data
!= MAP_FAILED
)
639 #if HAVE_POSIX_MADVISE
640 posix_madvise (descriptor
->map_addr
, descriptor
->map_len
,
641 POSIX_MADV_WILLNEED
);
646 /* On failure, clear out the section data and try again. */
647 memset (descriptor
, 0, sizeof (*descriptor
));
650 #endif /* HAVE_MMAP */
652 /* Handle compressed sections, or ordinary uncompressed sections in
655 descriptor
->size
= bfd_get_section_size (sectp
);
656 descriptor
->data
= NULL
;
659 if (!bfd_get_full_section_contents (abfd
, sectp
, &data
))
660 error (_("Can't read data for section '%s' in file '%s'"),
661 bfd_get_section_name (abfd
, sectp
),
662 bfd_get_filename (abfd
));
663 descriptor
->data
= data
;
666 gdb_assert (descriptor
->data
!= NULL
);
667 *size
= descriptor
->size
;
668 return descriptor
->data
;
671 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
672 return 1. Otherwise print a warning and return 0. ABFD seek position is
676 get_file_crc (bfd
*abfd
, unsigned long *file_crc_return
)
678 unsigned long file_crc
= 0;
680 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
682 warning (_("Problem reading \"%s\" for CRC: %s"),
683 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
689 gdb_byte buffer
[8 * 1024];
692 count
= bfd_bread (buffer
, sizeof (buffer
), abfd
);
693 if (count
== (bfd_size_type
) -1)
695 warning (_("Problem reading \"%s\" for CRC: %s"),
696 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
701 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
704 *file_crc_return
= file_crc
;
711 gdb_bfd_crc (struct bfd
*abfd
, unsigned long *crc_out
)
713 struct gdb_bfd_data
*gdata
= bfd_usrdata (abfd
);
715 if (!gdata
->crc_computed
)
716 gdata
->crc_computed
= get_file_crc (abfd
, &gdata
->crc
);
718 if (gdata
->crc_computed
)
719 *crc_out
= gdata
->crc
;
720 return gdata
->crc_computed
;
728 gdb_bfd_fopen (const char *filename
, const char *target
, const char *mode
,
731 bfd
*result
= bfd_fopen (filename
, target
, mode
, fd
);
734 gdb_bfd_ref (result
);
742 gdb_bfd_openr (const char *filename
, const char *target
)
744 bfd
*result
= bfd_openr (filename
, target
);
747 gdb_bfd_ref (result
);
755 gdb_bfd_openw (const char *filename
, const char *target
)
757 bfd
*result
= bfd_openw (filename
, target
);
760 gdb_bfd_ref (result
);
768 gdb_bfd_openr_iovec (const char *filename
, const char *target
,
769 void *(*open_func
) (struct bfd
*nbfd
,
772 file_ptr (*pread_func
) (struct bfd
*nbfd
,
777 int (*close_func
) (struct bfd
*nbfd
,
779 int (*stat_func
) (struct bfd
*abfd
,
783 bfd
*result
= bfd_openr_iovec (filename
, target
,
784 open_func
, open_closure
,
785 pread_func
, close_func
, stat_func
);
788 gdb_bfd_ref (result
);
796 gdb_bfd_mark_parent (bfd
*child
, bfd
*parent
)
798 struct gdb_bfd_data
*gdata
;
801 /* No need to stash the filename here, because we also keep a
802 reference on the parent archive. */
804 gdata
= bfd_usrdata (child
);
805 if (gdata
->archive_bfd
== NULL
)
807 gdata
->archive_bfd
= parent
;
808 gdb_bfd_ref (parent
);
811 gdb_assert (gdata
->archive_bfd
== parent
);
817 gdb_bfd_openr_next_archived_file (bfd
*archive
, bfd
*previous
)
819 bfd
*result
= bfd_openr_next_archived_file (archive
, previous
);
822 gdb_bfd_mark_parent (result
, archive
);
830 gdb_bfd_record_inclusion (bfd
*includer
, bfd
*includee
)
832 struct gdb_bfd_data
*gdata
;
834 gdb_bfd_ref (includee
);
835 gdata
= bfd_usrdata (includer
);
836 VEC_safe_push (bfdp
, gdata
->included_bfds
, includee
);
842 gdb_bfd_fdopenr (const char *filename
, const char *target
, int fd
)
844 bfd
*result
= bfd_fdopenr (filename
, target
, fd
);
847 gdb_bfd_ref (result
);
854 gdb_static_assert (ARRAY_SIZE (_bfd_std_section
) == 4);
859 gdb_bfd_section_index (bfd
*abfd
, asection
*section
)
863 else if (section
== bfd_com_section_ptr
)
864 return bfd_count_sections (abfd
);
865 else if (section
== bfd_und_section_ptr
)
866 return bfd_count_sections (abfd
) + 1;
867 else if (section
== bfd_abs_section_ptr
)
868 return bfd_count_sections (abfd
) + 2;
869 else if (section
== bfd_ind_section_ptr
)
870 return bfd_count_sections (abfd
) + 3;
871 return section
->index
;
877 gdb_bfd_count_sections (bfd
*abfd
)
879 return bfd_count_sections (abfd
) + 4;
885 gdb_bfd_requires_relocations (bfd
*abfd
)
887 struct gdb_bfd_data
*gdata
= bfd_usrdata (abfd
);
889 if (gdata
->relocation_computed
== 0)
893 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
894 if ((sect
->flags
& SEC_RELOC
) != 0)
896 gdata
->needs_relocations
= 1;
900 gdata
->relocation_computed
= 1;
903 return gdata
->needs_relocations
;
908 /* A callback for htab_traverse that prints a single BFD. */
911 print_one_bfd (void **slot
, void *data
)
914 struct gdb_bfd_data
*gdata
= bfd_usrdata (abfd
);
915 struct ui_out
*uiout
= data
;
916 struct cleanup
*inner
;
918 inner
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
919 ui_out_field_int (uiout
, "refcount", gdata
->refc
);
920 ui_out_field_string (uiout
, "addr", host_address_to_string (abfd
));
921 ui_out_field_string (uiout
, "filename", bfd_get_filename (abfd
));
922 ui_out_text (uiout
, "\n");
928 /* Implement the 'maint info bfd' command. */
931 maintenance_info_bfds (char *arg
, int from_tty
)
933 struct cleanup
*cleanup
;
934 struct ui_out
*uiout
= current_uiout
;
936 cleanup
= make_cleanup_ui_out_table_begin_end (uiout
, 3, -1, "bfds");
937 ui_out_table_header (uiout
, 10, ui_left
, "refcount", "Refcount");
938 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
939 ui_out_table_header (uiout
, 40, ui_left
, "filename", "Filename");
941 ui_out_table_body (uiout
);
942 htab_traverse (all_bfds
, print_one_bfd
, uiout
);
944 do_cleanups (cleanup
);
947 /* -Wmissing-prototypes */
948 extern initialize_file_ftype _initialize_gdb_bfd
;
951 _initialize_gdb_bfd (void)
953 all_bfds
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
954 NULL
, xcalloc
, xfree
);
956 add_cmd ("bfds", class_maintenance
, maintenance_info_bfds
, _("\
957 List the BFDs that are currently open."),
958 &maintenanceinfolist
);
960 add_setshow_boolean_cmd ("bfd-sharing", no_class
,
962 Set whether gdb will share bfds that appear to be the same file."), _("\
963 Show whether gdb will share bfds that appear to be the same file."), _("\
964 When enabled gdb will reuse existing bfds rather than reopening the\n\
965 same file. To decide if two files are the same then gdb compares the\n\
966 filename, file size, file modification time, and file inode."),
969 &maintenance_set_cmdlist
,
970 &maintenance_show_cmdlist
);