1 /* Definitions for BFD wrappers used by GDB.
3 Copyright (C) 2011-2021 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 /* Note that if ST is nullptr, then we simply fill in zeroes. */
63 gdb_bfd_data (bfd
*abfd
, struct stat
*st
)
64 : mtime (st
== nullptr ? 0 : st
->st_mtime
),
65 size (st
== nullptr ? 0 : st
->st_size
),
66 inode (st
== nullptr ? 0 : st
->st_ino
),
67 device_id (st
== nullptr ? 0 : st
->st_dev
),
68 relocation_computed (0),
69 needs_relocations (0),
78 /* The reference count. */
81 /* The mtime of the BFD at the point the cache entry was made. */
84 /* The file size (in bytes) at the point the cache entry was made. */
87 /* The inode of the file at the point the cache entry was made. */
90 /* The device id of the file at the point the cache entry was made. */
93 /* This is true if we have determined whether this BFD has any
94 sections requiring relocation. */
95 unsigned int relocation_computed
: 1;
97 /* This is true if any section needs relocation. */
98 unsigned int needs_relocations
: 1;
100 /* This is true if we have successfully computed the file's CRC. */
101 unsigned int crc_computed
: 1;
103 /* The file's CRC. */
104 unsigned long crc
= 0;
106 /* If the BFD comes from an archive, this points to the archive's
107 BFD. Otherwise, this is NULL. */
108 bfd
*archive_bfd
= nullptr;
110 /* Table of all the bfds this bfd has included. */
111 std::vector
<gdb_bfd_ref_ptr
> included_bfds
;
114 REGISTRY_FIELDS
= {};
117 #define GDB_BFD_DATA_ACCESSOR(ABFD) \
118 ((struct gdb_bfd_data *) bfd_usrdata (ABFD))
120 DEFINE_REGISTRY (bfd
, GDB_BFD_DATA_ACCESSOR
)
122 /* A hash table storing all the BFDs maintained in the cache. */
124 static htab_t gdb_bfd_cache
;
126 /* When true gdb will reuse an existing bfd object if the filename,
127 modification time, and file size all match. */
129 static bool bfd_sharing
= true;
131 show_bfd_sharing (struct ui_file
*file
, int from_tty
,
132 struct cmd_list_element
*c
, const char *value
)
134 fprintf_filtered (file
, _("BFD sharing is %s.\n"), value
);
137 /* When true debugging of the bfd caches is enabled. */
139 static bool debug_bfd_cache
;
141 /* Print an "bfd-cache" debug statement. */
143 #define bfd_cache_debug_printf(fmt, ...) \
144 debug_prefixed_printf_cond (debug_bfd_cache, "bfd-cache", fmt, ##__VA_ARGS__)
147 show_bfd_cache_debug (struct ui_file
*file
, int from_tty
,
148 struct cmd_list_element
*c
, const char *value
)
150 fprintf_filtered (file
, _("BFD cache debugging is %s.\n"), value
);
153 /* The type of an object being looked up in gdb_bfd_cache. We use
154 htab's capability of storing one kind of object (BFD in this case)
155 and using a different sort of object for searching. */
157 struct gdb_bfd_cache_search
160 const char *filename
;
163 /* The file size (in bytes). */
165 /* The inode of the file. */
167 /* The device id of the file. */
171 /* A hash function for BFDs. */
174 hash_bfd (const void *b
)
176 const bfd
*abfd
= (const struct bfd
*) b
;
178 /* It is simplest to just hash the filename. */
179 return htab_hash_string (bfd_get_filename (abfd
));
182 /* An equality function for BFDs. Note that this expects the caller
183 to search using struct gdb_bfd_cache_search only, not BFDs. */
186 eq_bfd (const void *a
, const void *b
)
188 const bfd
*abfd
= (const struct bfd
*) a
;
189 const struct gdb_bfd_cache_search
*s
190 = (const struct gdb_bfd_cache_search
*) b
;
191 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
193 return (gdata
->mtime
== s
->mtime
194 && gdata
->size
== s
->size
195 && gdata
->inode
== s
->inode
196 && gdata
->device_id
== s
->device_id
197 && strcmp (bfd_get_filename (abfd
), s
->filename
) == 0);
203 is_target_filename (const char *name
)
205 return startswith (name
, TARGET_SYSROOT_PREFIX
);
211 gdb_bfd_has_target_filename (struct bfd
*abfd
)
213 return is_target_filename (bfd_get_filename (abfd
));
216 /* For `gdb_bfd_open_from_target_memory`. */
224 /* For `gdb_bfd_open_from_target_memory`. Opening the file is a no-op. */
227 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
232 /* For `gdb_bfd_open_from_target_memory`. Closing the file is just freeing the
233 base/size pair on our side. */
236 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
240 /* Zero means success. */
244 /* For `gdb_bfd_open_from_target_memory`. For reading the file, we just need to
245 pass through to target_read_memory and fix up the arguments and return
249 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
250 file_ptr nbytes
, file_ptr offset
)
253 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
255 /* If this read will read all of the file, limit it to just the rest. */
256 if (offset
+ nbytes
> buffer
->size
)
257 nbytes
= buffer
->size
- offset
;
259 /* If there are no more bytes left, we've reached EOF. */
263 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
270 /* For `gdb_bfd_open_from_target_memory`. For statting the file, we only
271 support the st_size attribute. */
274 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
276 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
278 memset (sb
, 0, sizeof (struct stat
));
279 sb
->st_size
= buffer
->size
;
286 gdb_bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
,
288 const char *filename
)
290 struct target_buffer
*buffer
= XNEW (struct target_buffer
);
294 return gdb_bfd_openr_iovec (filename
? filename
: "<in-memory>", target
,
302 /* Return the system error number corresponding to ERRNUM. */
305 fileio_errno_to_host (int errnum
)
349 case FILEIO_ENAMETOOLONG
:
355 /* bfd_openr_iovec OPEN_CLOSURE data for gdb_bfd_open. */
356 struct gdb_bfd_open_closure
362 /* Wrapper for target_fileio_open suitable for passing as the
363 OPEN_FUNC argument to gdb_bfd_openr_iovec. */
366 gdb_bfd_iovec_fileio_open (struct bfd
*abfd
, void *open_closure
)
368 const char *filename
= bfd_get_filename (abfd
);
369 int fd
, target_errno
;
371 gdb_bfd_open_closure
*oclosure
= (gdb_bfd_open_closure
*) open_closure
;
373 gdb_assert (is_target_filename (filename
));
375 fd
= target_fileio_open (oclosure
->inf
,
376 filename
+ strlen (TARGET_SYSROOT_PREFIX
),
377 FILEIO_O_RDONLY
, 0, oclosure
->warn_if_slow
,
381 errno
= fileio_errno_to_host (target_errno
);
382 bfd_set_error (bfd_error_system_call
);
386 stream
= XCNEW (int);
391 /* Wrapper for target_fileio_pread suitable for passing as the
392 PREAD_FUNC argument to gdb_bfd_openr_iovec. */
395 gdb_bfd_iovec_fileio_pread (struct bfd
*abfd
, void *stream
, void *buf
,
396 file_ptr nbytes
, file_ptr offset
)
398 int fd
= *(int *) stream
;
407 bytes
= target_fileio_pread (fd
, (gdb_byte
*) buf
+ pos
,
408 nbytes
- pos
, offset
+ pos
,
411 /* Success, but no bytes, means end-of-file. */
415 errno
= fileio_errno_to_host (target_errno
);
416 bfd_set_error (bfd_error_system_call
);
426 /* Wrapper for target_fileio_close suitable for passing as the
427 CLOSE_FUNC argument to gdb_bfd_openr_iovec. */
430 gdb_bfd_iovec_fileio_close (struct bfd
*abfd
, void *stream
)
432 int fd
= *(int *) stream
;
437 /* Ignore errors on close. These may happen with remote
438 targets if the connection has already been torn down. */
439 target_fileio_close (fd
, &target_errno
);
441 /* Zero means success. */
445 /* Wrapper for target_fileio_fstat suitable for passing as the
446 STAT_FUNC argument to gdb_bfd_openr_iovec. */
449 gdb_bfd_iovec_fileio_fstat (struct bfd
*abfd
, void *stream
,
452 int fd
= *(int *) stream
;
456 result
= target_fileio_fstat (fd
, sb
, &target_errno
);
459 errno
= fileio_errno_to_host (target_errno
);
460 bfd_set_error (bfd_error_system_call
);
466 /* A helper function to initialize the data that gdb attaches to each
470 gdb_bfd_init_data (struct bfd
*abfd
, struct stat
*st
)
472 struct gdb_bfd_data
*gdata
;
475 gdb_assert (bfd_usrdata (abfd
) == nullptr);
477 /* Ask BFD to decompress sections in bfd_get_full_section_contents. */
478 abfd
->flags
|= BFD_DECOMPRESS
;
480 gdata
= new gdb_bfd_data (abfd
, st
);
481 bfd_set_usrdata (abfd
, gdata
);
482 bfd_alloc_data (abfd
);
484 /* This is the first we've seen it, so add it to the hash table. */
485 slot
= htab_find_slot (all_bfds
, abfd
, INSERT
);
486 gdb_assert (slot
&& !*slot
);
493 gdb_bfd_open (const char *name
, const char *target
, int fd
,
499 struct gdb_bfd_cache_search search
;
502 if (is_target_filename (name
))
504 if (!target_filesystem_is_local ())
506 gdb_assert (fd
== -1);
508 gdb_bfd_open_closure open_closure
{ current_inferior (), warn_if_slow
};
509 return gdb_bfd_openr_iovec (name
, target
,
510 gdb_bfd_iovec_fileio_open
,
512 gdb_bfd_iovec_fileio_pread
,
513 gdb_bfd_iovec_fileio_close
,
514 gdb_bfd_iovec_fileio_fstat
);
517 name
+= strlen (TARGET_SYSROOT_PREFIX
);
520 if (gdb_bfd_cache
== NULL
)
521 gdb_bfd_cache
= htab_create_alloc (1, hash_bfd
, eq_bfd
, NULL
,
526 fd
= gdb_open_cloexec (name
, O_RDONLY
| O_BINARY
, 0);
529 bfd_set_error (bfd_error_system_call
);
534 if (fstat (fd
, &st
) < 0)
536 /* Weird situation here -- don't cache if we can't stat. */
537 bfd_cache_debug_printf ("Could not stat %s - not caching", name
);
538 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
541 return gdb_bfd_ref_ptr::new_reference (abfd
);
544 search
.filename
= name
;
545 search
.mtime
= st
.st_mtime
;
546 search
.size
= st
.st_size
;
547 search
.inode
= st
.st_ino
;
548 search
.device_id
= st
.st_dev
;
550 /* Note that this must compute the same result as hash_bfd. */
551 hash
= htab_hash_string (name
);
552 /* Note that we cannot use htab_find_slot_with_hash here, because
553 opening the BFD may fail; and this would violate hashtab
555 abfd
= (struct bfd
*) htab_find_with_hash (gdb_bfd_cache
, &search
, hash
);
556 if (bfd_sharing
&& abfd
!= NULL
)
558 bfd_cache_debug_printf ("Reusing cached bfd %s for %s",
559 host_address_to_string (abfd
),
560 bfd_get_filename (abfd
));
562 return gdb_bfd_ref_ptr::new_reference (abfd
);
565 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
569 bfd_cache_debug_printf ("Creating new bfd %s for %s",
570 host_address_to_string (abfd
),
571 bfd_get_filename (abfd
));
575 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
, INSERT
);
580 /* It's important to pass the already-computed stat info here,
581 rather than, say, calling gdb_bfd_ref_ptr::new_reference. BFD by
582 default will "stat" the file each time bfd_get_mtime is called --
583 and since we already entered it into the hash table using this
584 mtime, if the file changed at the wrong moment, the race would
585 lead to a hash table corruption. */
586 gdb_bfd_init_data (abfd
, &st
);
587 return gdb_bfd_ref_ptr (abfd
);
590 /* A helper function that releases any section data attached to the
594 free_one_bfd_section (asection
*sectp
)
596 struct gdb_bfd_section_data
*sect
597 = (struct gdb_bfd_section_data
*) bfd_section_userdata (sectp
);
599 if (sect
!= NULL
&& sect
->data
!= NULL
)
602 if (sect
->map_addr
!= NULL
)
606 res
= munmap (sect
->map_addr
, sect
->map_len
);
607 gdb_assert (res
== 0);
615 /* Close ABFD, and warn if that fails. */
618 gdb_bfd_close_or_warn (struct bfd
*abfd
)
621 const char *name
= bfd_get_filename (abfd
);
623 for (asection
*sect
: gdb_bfd_sections (abfd
))
624 free_one_bfd_section (sect
);
626 ret
= bfd_close (abfd
);
629 warning (_("cannot close \"%s\": %s"),
630 name
, bfd_errmsg (bfd_get_error ()));
638 gdb_bfd_ref (struct bfd
*abfd
)
640 struct gdb_bfd_data
*gdata
;
645 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
647 bfd_cache_debug_printf ("Increase reference count on bfd %s (%s)",
648 host_address_to_string (abfd
),
649 bfd_get_filename (abfd
));
657 /* Caching only happens via gdb_bfd_open, so passing nullptr here is
659 gdb_bfd_init_data (abfd
, nullptr);
665 gdb_bfd_unref (struct bfd
*abfd
)
667 struct gdb_bfd_data
*gdata
;
668 struct gdb_bfd_cache_search search
;
674 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
675 gdb_assert (gdata
->refc
>= 1);
680 bfd_cache_debug_printf ("Decrease reference count on bfd %s (%s)",
681 host_address_to_string (abfd
),
682 bfd_get_filename (abfd
));
686 bfd_cache_debug_printf ("Delete final reference count on bfd %s (%s)",
687 host_address_to_string (abfd
),
688 bfd_get_filename (abfd
));
690 archive_bfd
= gdata
->archive_bfd
;
691 search
.filename
= bfd_get_filename (abfd
);
693 if (gdb_bfd_cache
&& search
.filename
)
695 hashval_t hash
= htab_hash_string (search
.filename
);
698 search
.mtime
= gdata
->mtime
;
699 search
.size
= gdata
->size
;
700 search
.inode
= gdata
->inode
;
701 search
.device_id
= gdata
->device_id
;
702 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
,
706 htab_clear_slot (gdb_bfd_cache
, slot
);
709 bfd_free_data (abfd
);
711 bfd_set_usrdata (abfd
, NULL
); /* Paranoia. */
713 htab_remove_elt (all_bfds
, abfd
);
715 gdb_bfd_close_or_warn (abfd
);
717 gdb_bfd_unref (archive_bfd
);
720 /* A helper function that returns the section data descriptor
721 associated with SECTION. If no such descriptor exists, a new one
722 is allocated and cleared. */
724 static struct gdb_bfd_section_data
*
725 get_section_descriptor (asection
*section
)
727 struct gdb_bfd_section_data
*result
;
729 result
= (struct gdb_bfd_section_data
*) bfd_section_userdata (section
);
733 result
= ((struct gdb_bfd_section_data
*)
734 bfd_zalloc (section
->owner
, sizeof (*result
)));
735 bfd_set_section_userdata (section
, result
);
744 gdb_bfd_map_section (asection
*sectp
, bfd_size_type
*size
)
747 struct gdb_bfd_section_data
*descriptor
;
750 gdb_assert ((sectp
->flags
& SEC_RELOC
) == 0);
751 gdb_assert (size
!= NULL
);
755 descriptor
= get_section_descriptor (sectp
);
757 /* If the data was already read for this BFD, just reuse it. */
758 if (descriptor
->data
!= NULL
)
762 if (!bfd_is_section_compressed (abfd
, sectp
))
764 /* The page size, used when mmapping. */
768 pagesize
= getpagesize ();
770 /* Only try to mmap sections which are large enough: we don't want
771 to waste space due to fragmentation. */
773 if (bfd_section_size (sectp
) > 4 * pagesize
)
775 descriptor
->size
= bfd_section_size (sectp
);
776 descriptor
->data
= bfd_mmap (abfd
, 0, descriptor
->size
, PROT_READ
,
777 MAP_PRIVATE
, sectp
->filepos
,
778 &descriptor
->map_addr
,
779 &descriptor
->map_len
);
781 if ((caddr_t
)descriptor
->data
!= MAP_FAILED
)
783 #if HAVE_POSIX_MADVISE
784 posix_madvise (descriptor
->map_addr
, descriptor
->map_len
,
785 POSIX_MADV_WILLNEED
);
790 /* On failure, clear out the section data and try again. */
791 memset (descriptor
, 0, sizeof (*descriptor
));
794 #endif /* HAVE_MMAP */
796 /* Handle compressed sections, or ordinary uncompressed sections in
799 descriptor
->size
= bfd_section_size (sectp
);
800 descriptor
->data
= NULL
;
803 if (!bfd_get_full_section_contents (abfd
, sectp
, &data
))
805 warning (_("Can't read data for section '%s' in file '%s'"),
806 bfd_section_name (sectp
),
807 bfd_get_filename (abfd
));
808 /* Set size to 0 to prevent further attempts to read the invalid
813 descriptor
->data
= data
;
816 gdb_assert (descriptor
->data
!= NULL
);
817 *size
= descriptor
->size
;
818 return (const gdb_byte
*) descriptor
->data
;
821 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
822 return 1. Otherwise print a warning and return 0. ABFD seek position is
826 get_file_crc (bfd
*abfd
, unsigned long *file_crc_return
)
828 unsigned long file_crc
= 0;
830 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
832 warning (_("Problem reading \"%s\" for CRC: %s"),
833 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
839 gdb_byte buffer
[8 * 1024];
842 count
= bfd_bread (buffer
, sizeof (buffer
), abfd
);
843 if (count
== (bfd_size_type
) -1)
845 warning (_("Problem reading \"%s\" for CRC: %s"),
846 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
851 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
854 *file_crc_return
= file_crc
;
861 gdb_bfd_crc (struct bfd
*abfd
, unsigned long *crc_out
)
863 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
865 if (!gdata
->crc_computed
)
866 gdata
->crc_computed
= get_file_crc (abfd
, &gdata
->crc
);
868 if (gdata
->crc_computed
)
869 *crc_out
= gdata
->crc
;
870 return gdata
->crc_computed
;
878 gdb_bfd_fopen (const char *filename
, const char *target
, const char *mode
,
881 bfd
*result
= bfd_fopen (filename
, target
, mode
, fd
);
883 return gdb_bfd_ref_ptr::new_reference (result
);
889 gdb_bfd_openr (const char *filename
, const char *target
)
891 bfd
*result
= bfd_openr (filename
, target
);
893 return gdb_bfd_ref_ptr::new_reference (result
);
899 gdb_bfd_openw (const char *filename
, const char *target
)
901 bfd
*result
= bfd_openw (filename
, target
);
903 return gdb_bfd_ref_ptr::new_reference (result
);
909 gdb_bfd_openr_iovec (const char *filename
, const char *target
,
910 void *(*open_func
) (struct bfd
*nbfd
,
913 file_ptr (*pread_func
) (struct bfd
*nbfd
,
918 int (*close_func
) (struct bfd
*nbfd
,
920 int (*stat_func
) (struct bfd
*abfd
,
924 bfd
*result
= bfd_openr_iovec (filename
, target
,
925 open_func
, open_closure
,
926 pread_func
, close_func
, stat_func
);
928 return gdb_bfd_ref_ptr::new_reference (result
);
934 gdb_bfd_mark_parent (bfd
*child
, bfd
*parent
)
936 struct gdb_bfd_data
*gdata
;
939 /* No need to stash the filename here, because we also keep a
940 reference on the parent archive. */
942 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (child
);
943 if (gdata
->archive_bfd
== NULL
)
945 gdata
->archive_bfd
= parent
;
946 gdb_bfd_ref (parent
);
949 gdb_assert (gdata
->archive_bfd
== parent
);
955 gdb_bfd_openr_next_archived_file (bfd
*archive
, bfd
*previous
)
957 bfd
*result
= bfd_openr_next_archived_file (archive
, previous
);
960 gdb_bfd_mark_parent (result
, archive
);
962 return gdb_bfd_ref_ptr (result
);
968 gdb_bfd_record_inclusion (bfd
*includer
, bfd
*includee
)
970 struct gdb_bfd_data
*gdata
;
972 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (includer
);
973 gdata
->included_bfds
.push_back (gdb_bfd_ref_ptr::new_reference (includee
));
978 gdb_static_assert (ARRAY_SIZE (_bfd_std_section
) == 4);
983 gdb_bfd_section_index (bfd
*abfd
, asection
*section
)
987 else if (section
== bfd_com_section_ptr
)
988 return bfd_count_sections (abfd
);
989 else if (section
== bfd_und_section_ptr
)
990 return bfd_count_sections (abfd
) + 1;
991 else if (section
== bfd_abs_section_ptr
)
992 return bfd_count_sections (abfd
) + 2;
993 else if (section
== bfd_ind_section_ptr
)
994 return bfd_count_sections (abfd
) + 3;
995 return section
->index
;
1001 gdb_bfd_count_sections (bfd
*abfd
)
1003 return bfd_count_sections (abfd
) + 4;
1006 /* See gdb_bfd.h. */
1009 gdb_bfd_requires_relocations (bfd
*abfd
)
1011 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
1013 if (gdata
->relocation_computed
== 0)
1017 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
1018 if ((sect
->flags
& SEC_RELOC
) != 0)
1020 gdata
->needs_relocations
= 1;
1024 gdata
->relocation_computed
= 1;
1027 return gdata
->needs_relocations
;
1030 /* See gdb_bfd.h. */
1033 gdb_bfd_get_full_section_contents (bfd
*abfd
, asection
*section
,
1034 gdb::byte_vector
*contents
)
1036 bfd_size_type section_size
= bfd_section_size (section
);
1038 contents
->resize (section_size
);
1040 return bfd_get_section_contents (abfd
, section
, contents
->data (), 0,
1044 /* A callback for htab_traverse that prints a single BFD. */
1047 print_one_bfd (void **slot
, void *data
)
1049 bfd
*abfd
= (struct bfd
*) *slot
;
1050 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
1051 struct ui_out
*uiout
= (struct ui_out
*) data
;
1053 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1054 uiout
->field_signed ("refcount", gdata
->refc
);
1055 uiout
->field_string ("addr", host_address_to_string (abfd
));
1056 uiout
->field_string ("filename", bfd_get_filename (abfd
));
1062 /* Implement the 'maint info bfd' command. */
1065 maintenance_info_bfds (const char *arg
, int from_tty
)
1067 struct ui_out
*uiout
= current_uiout
;
1069 ui_out_emit_table
table_emitter (uiout
, 3, -1, "bfds");
1070 uiout
->table_header (10, ui_left
, "refcount", "Refcount");
1071 uiout
->table_header (18, ui_left
, "addr", "Address");
1072 uiout
->table_header (40, ui_left
, "filename", "Filename");
1074 uiout
->table_body ();
1075 htab_traverse (all_bfds
, print_one_bfd
, uiout
);
1078 void _initialize_gdb_bfd ();
1080 _initialize_gdb_bfd ()
1082 all_bfds
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
1083 NULL
, xcalloc
, xfree
);
1085 add_cmd ("bfds", class_maintenance
, maintenance_info_bfds
, _("\
1086 List the BFDs that are currently open."),
1087 &maintenanceinfolist
);
1089 add_setshow_boolean_cmd ("bfd-sharing", no_class
,
1091 Set whether gdb will share bfds that appear to be the same file."), _("\
1092 Show whether gdb will share bfds that appear to be the same file."), _("\
1093 When enabled gdb will reuse existing bfds rather than reopening the\n\
1094 same file. To decide if two files are the same then gdb compares the\n\
1095 filename, file size, file modification time, and file inode."),
1098 &maintenance_set_cmdlist
,
1099 &maintenance_show_cmdlist
);
1101 add_setshow_boolean_cmd ("bfd-cache", class_maintenance
,
1103 _("Set bfd cache debugging."),
1104 _("Show bfd cache debugging."),
1106 When non-zero, bfd cache specific debugging is enabled."),
1108 &show_bfd_cache_debug
,
1109 &setdebuglist
, &showdebuglist
);