1 /* Definitions for BFD wrappers used by GDB.
3 Copyright (C) 2011-2024 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/>. */
21 #include "event-top.h"
25 #include "gdbsupport/filestuff.h"
29 #define MAP_FAILED ((void *) -1)
33 #include "gdbsupport/fileio.h"
35 #include "cli/cli-style.h"
36 #include <unordered_map>
42 /* Lock held when doing BFD operations. A recursive mutex is used
43 because we use this mutex internally and also for BFD, just to make
44 life a bit simpler, and we may sometimes hold it while calling into
46 static std::recursive_mutex gdb_bfd_mutex
;
48 /* BFD locking function. */
51 gdb_bfd_lock (void *ignore
)
53 gdb_bfd_mutex
.lock ();
57 /* BFD unlocking function. */
60 gdb_bfd_unlock (void *ignore
)
62 gdb_bfd_mutex
.unlock ();
66 #endif /* CXX_STD_THREAD */
68 /* An object of this type is stored in the section's user data when
71 struct gdb_bfd_section_data
73 /* Size of the data. */
75 /* If the data was mmapped, this is the length of the map. */
77 /* The data. If NULL, the section data has not been read. */
79 /* If the data was mmapped, this is the map address. */
83 /* A hash table holding every BFD that gdb knows about. This is not
84 to be confused with 'gdb_bfd_cache', which is used for sharing
85 BFDs; in contrast, this hash is used just to implement
88 static htab_t all_bfds
;
90 /* An object of this type is stored in each BFD's user data. */
94 /* Note that if ST is nullptr, then we simply fill in zeroes. */
95 gdb_bfd_data (bfd
*abfd
, struct stat
*st
)
96 : mtime (st
== nullptr ? 0 : st
->st_mtime
),
97 size (st
== nullptr ? 0 : st
->st_size
),
98 inode (st
== nullptr ? 0 : st
->st_ino
),
99 device_id (st
== nullptr ? 0 : st
->st_dev
),
100 relocation_computed (0),
101 needs_relocations (0),
110 /* The reference count. */
113 /* The mtime of the BFD at the point the cache entry was made. */
116 /* The file size (in bytes) at the point the cache entry was made. */
119 /* The inode of the file at the point the cache entry was made. */
122 /* The device id of the file at the point the cache entry was made. */
125 /* This is true if we have determined whether this BFD has any
126 sections requiring relocation. */
127 unsigned int relocation_computed
: 1;
129 /* This is true if any section needs relocation. */
130 unsigned int needs_relocations
: 1;
132 /* This is true if we have successfully computed the file's CRC. */
133 unsigned int crc_computed
: 1;
135 /* The file's CRC. */
136 unsigned long crc
= 0;
138 /* If the BFD comes from an archive, this points to the archive's
139 BFD. Otherwise, this is NULL. */
140 bfd
*archive_bfd
= nullptr;
142 /* Table of all the bfds this bfd has included. */
143 std::vector
<gdb_bfd_ref_ptr
> included_bfds
;
146 registry
<bfd
> registry_fields
;
150 registry_accessor
<bfd
>::get (bfd
*abfd
)
152 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
153 return &gdata
->registry_fields
;
156 /* A hash table storing all the BFDs maintained in the cache. */
158 static htab_t gdb_bfd_cache
;
160 /* When true gdb will reuse an existing bfd object if the filename,
161 modification time, and file size all match. */
163 static bool bfd_sharing
= true;
165 show_bfd_sharing (struct ui_file
*file
, int from_tty
,
166 struct cmd_list_element
*c
, const char *value
)
168 gdb_printf (file
, _("BFD sharing is %s.\n"), value
);
171 /* When true debugging of the bfd caches is enabled. */
173 static bool debug_bfd_cache
;
175 /* Print an "bfd-cache" debug statement. */
177 #define bfd_cache_debug_printf(fmt, ...) \
178 debug_prefixed_printf_cond (debug_bfd_cache, "bfd-cache", fmt, ##__VA_ARGS__)
181 show_bfd_cache_debug (struct ui_file
*file
, int from_tty
,
182 struct cmd_list_element
*c
, const char *value
)
184 gdb_printf (file
, _("BFD cache debugging is %s.\n"), value
);
187 /* The type of an object being looked up in gdb_bfd_cache. We use
188 htab's capability of storing one kind of object (BFD in this case)
189 and using a different sort of object for searching. */
191 struct gdb_bfd_cache_search
194 const char *filename
;
197 /* The file size (in bytes). */
199 /* The inode of the file. */
201 /* The device id of the file. */
205 /* A hash function for BFDs. */
208 hash_bfd (const void *b
)
210 const bfd
*abfd
= (const struct bfd
*) b
;
212 /* It is simplest to just hash the filename. */
213 return htab_hash_string (bfd_get_filename (abfd
));
216 /* An equality function for BFDs. Note that this expects the caller
217 to search using struct gdb_bfd_cache_search only, not BFDs. */
220 eq_bfd (const void *a
, const void *b
)
222 const bfd
*abfd
= (const struct bfd
*) a
;
223 const struct gdb_bfd_cache_search
*s
224 = (const struct gdb_bfd_cache_search
*) b
;
225 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
227 return (gdata
->mtime
== s
->mtime
228 && gdata
->size
== s
->size
229 && gdata
->inode
== s
->inode
230 && gdata
->device_id
== s
->device_id
231 && strcmp (bfd_get_filename (abfd
), s
->filename
) == 0);
237 is_target_filename (const char *name
)
239 return startswith (name
, TARGET_SYSROOT_PREFIX
);
245 gdb_bfd_has_target_filename (struct bfd
*abfd
)
247 return is_target_filename (bfd_get_filename (abfd
));
250 /* For `gdb_bfd_open_from_target_memory`. An object that manages the
251 details of a BFD in target memory. */
253 struct target_buffer
: public gdb_bfd_iovec_base
255 /* Constructor. BASE and SIZE define where the BFD can be found in
257 target_buffer (CORE_ADDR base
, ULONGEST size
)
260 m_filename (xstrprintf ("<in-memory@%s-%s>",
261 core_addr_to_string_nz (m_base
),
262 core_addr_to_string_nz (m_base
+ m_size
)))
266 /* Return the size of the in-memory BFD file. */
267 ULONGEST
size () const
270 /* Return the base address of the in-memory BFD file. */
271 CORE_ADDR
base () const
274 /* Return a generated filename for the in-memory BFD file. The generated
275 name will include the begin and end address of the in-memory file. */
276 const char *filename () const
277 { return m_filename
.get (); }
279 file_ptr
read (bfd
*abfd
, void *buffer
, file_ptr nbytes
,
280 file_ptr offset
) override
;
282 int stat (struct bfd
*abfd
, struct stat
*sb
) override
;
285 /* The base address of the in-memory BFD file. */
288 /* The size (in-bytes) of the in-memory BFD file. */
291 /* Holds the generated name of the in-memory BFD file. */
292 gdb::unique_xmalloc_ptr
<char> m_filename
;
295 /* For `gdb_bfd_open_from_target_memory`. For reading the file, we just need to
296 pass through to target_read_memory and fix up the arguments and return
300 target_buffer::read (struct bfd
*abfd
, void *buf
,
301 file_ptr nbytes
, file_ptr offset
)
303 /* If this read will read all of the file, limit it to just the rest. */
304 if (offset
+ nbytes
> size ())
305 nbytes
= size () - offset
;
307 /* If there are no more bytes left, we've reached EOF. */
311 int err
= target_read_memory (base () + offset
, (gdb_byte
*) buf
, nbytes
);
318 /* For `gdb_bfd_open_from_target_memory`. For statting the file, we only
319 support the st_size attribute. */
322 target_buffer::stat (struct bfd
*abfd
, struct stat
*sb
)
324 memset (sb
, 0, sizeof (struct stat
));
325 sb
->st_size
= size ();
332 gdb_bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
,
335 std::unique_ptr
<target_buffer
> buffer
336 = std::make_unique
<target_buffer
> (addr
, size
);
338 return gdb_bfd_openr_iovec (buffer
->filename (), target
,
341 return buffer
.release ();
345 /* An object that manages the underlying stream for a BFD, using
348 struct target_fileio_stream
: public gdb_bfd_iovec_base
350 target_fileio_stream (bfd
*nbfd
, int fd
)
356 ~target_fileio_stream ();
358 file_ptr
read (bfd
*abfd
, void *buffer
, file_ptr nbytes
,
359 file_ptr offset
) override
;
361 int stat (struct bfd
*abfd
, struct stat
*sb
) override
;
365 /* The BFD. Saved for the destructor. */
368 /* The file descriptor. */
372 /* Wrapper for target_fileio_open suitable for use as a helper
373 function for gdb_bfd_openr_iovec. */
375 static target_fileio_stream
*
376 gdb_bfd_iovec_fileio_open (struct bfd
*abfd
, inferior
*inf
, bool warn_if_slow
)
378 const char *filename
= bfd_get_filename (abfd
);
380 fileio_error target_errno
;
382 gdb_assert (is_target_filename (filename
));
384 fd
= target_fileio_open (inf
,
385 filename
+ strlen (TARGET_SYSROOT_PREFIX
),
386 FILEIO_O_RDONLY
, 0, warn_if_slow
,
390 errno
= fileio_error_to_host (target_errno
);
391 bfd_set_error (bfd_error_system_call
);
395 return new target_fileio_stream (abfd
, fd
);
398 /* Wrapper for target_fileio_pread. */
401 target_fileio_stream::read (struct bfd
*abfd
, void *buf
,
402 file_ptr nbytes
, file_ptr offset
)
404 fileio_error target_errno
;
412 bytes
= target_fileio_pread (m_fd
, (gdb_byte
*) buf
+ pos
,
413 nbytes
- pos
, offset
+ pos
,
416 /* Success, but no bytes, means end-of-file. */
420 errno
= fileio_error_to_host (target_errno
);
421 bfd_set_error (bfd_error_system_call
);
431 /* Warn that it wasn't possible to close a bfd for file NAME, because
435 gdb_bfd_close_warning (const char *name
, const char *reason
)
437 warning (_("cannot close \"%s\": %s"), name
, reason
);
440 /* Wrapper for target_fileio_close. */
442 target_fileio_stream::~target_fileio_stream ()
444 fileio_error target_errno
;
446 /* Ignore errors on close. These may happen with remote
447 targets if the connection has already been torn down. */
450 target_fileio_close (m_fd
, &target_errno
);
452 catch (const gdb_exception
&ex
)
454 /* Also avoid crossing exceptions over bfd. */
455 gdb_bfd_close_warning (bfd_get_filename (m_bfd
),
456 ex
.message
->c_str ());
460 /* Wrapper for target_fileio_fstat. */
463 target_fileio_stream::stat (struct bfd
*abfd
, struct stat
*sb
)
465 fileio_error target_errno
;
468 result
= target_fileio_fstat (m_fd
, sb
, &target_errno
);
471 errno
= fileio_error_to_host (target_errno
);
472 bfd_set_error (bfd_error_system_call
);
478 /* A helper function to initialize the data that gdb attaches to each
482 gdb_bfd_init_data (struct bfd
*abfd
, struct stat
*st
)
484 struct gdb_bfd_data
*gdata
;
487 gdb_assert (bfd_usrdata (abfd
) == nullptr);
489 /* Ask BFD to decompress sections in bfd_get_full_section_contents. */
490 abfd
->flags
|= BFD_DECOMPRESS
;
492 gdata
= new gdb_bfd_data (abfd
, st
);
493 bfd_set_usrdata (abfd
, gdata
);
495 /* This is the first we've seen it, so add it to the hash table. */
496 slot
= htab_find_slot (all_bfds
, abfd
, INSERT
);
497 gdb_assert (slot
&& !*slot
);
504 gdb_bfd_open (const char *name
, const char *target
, int fd
,
510 struct gdb_bfd_cache_search search
;
513 if (is_target_filename (name
))
515 if (!target_filesystem_is_local ())
517 gdb_assert (fd
== -1);
519 auto open
= [&] (bfd
*nbfd
) -> gdb_bfd_iovec_base
*
521 return gdb_bfd_iovec_fileio_open (nbfd
, current_inferior (),
525 return gdb_bfd_openr_iovec (name
, target
, open
);
528 name
+= strlen (TARGET_SYSROOT_PREFIX
);
532 std::lock_guard
<std::recursive_mutex
> guard (gdb_bfd_mutex
);
535 if (gdb_bfd_cache
== NULL
)
536 gdb_bfd_cache
= htab_create_alloc (1, hash_bfd
, eq_bfd
, NULL
,
541 fd
= gdb_open_cloexec (name
, O_RDONLY
| O_BINARY
, 0).release ();
544 bfd_set_error (bfd_error_system_call
);
549 if (fstat (fd
, &st
) < 0)
551 /* Weird situation here -- don't cache if we can't stat. */
552 bfd_cache_debug_printf ("Could not stat %s - not caching", name
);
553 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
556 return gdb_bfd_ref_ptr::new_reference (abfd
);
559 search
.filename
= name
;
560 search
.mtime
= st
.st_mtime
;
561 search
.size
= st
.st_size
;
562 search
.inode
= st
.st_ino
;
563 search
.device_id
= st
.st_dev
;
565 /* Note that this must compute the same result as hash_bfd. */
566 hash
= htab_hash_string (name
);
567 /* Note that we cannot use htab_find_slot_with_hash here, because
568 opening the BFD may fail; and this would violate hashtab
570 abfd
= (struct bfd
*) htab_find_with_hash (gdb_bfd_cache
, &search
, hash
);
571 if (bfd_sharing
&& abfd
!= NULL
)
573 bfd_cache_debug_printf ("Reusing cached bfd %s for %s",
574 host_address_to_string (abfd
),
575 bfd_get_filename (abfd
));
577 return gdb_bfd_ref_ptr::new_reference (abfd
);
580 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
584 bfd_set_cacheable (abfd
, 1);
586 bfd_cache_debug_printf ("Creating new bfd %s for %s",
587 host_address_to_string (abfd
),
588 bfd_get_filename (abfd
));
592 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
, INSERT
);
597 /* It's important to pass the already-computed stat info here,
598 rather than, say, calling gdb_bfd_ref_ptr::new_reference. BFD by
599 default will "stat" the file each time bfd_get_mtime is called --
600 and since we already entered it into the hash table using this
601 mtime, if the file changed at the wrong moment, the race would
602 lead to a hash table corruption. */
603 gdb_bfd_init_data (abfd
, &st
);
604 return gdb_bfd_ref_ptr (abfd
);
607 /* A helper function that releases any section data attached to the
611 free_one_bfd_section (asection
*sectp
)
613 struct gdb_bfd_section_data
*sect
614 = (struct gdb_bfd_section_data
*) bfd_section_userdata (sectp
);
616 if (sect
!= NULL
&& sect
->data
!= NULL
)
619 if (sect
->map_addr
!= NULL
)
623 res
= munmap (sect
->map_addr
, sect
->map_len
);
624 gdb_assert (res
== 0);
632 /* Close ABFD, and warn if that fails. */
635 gdb_bfd_close_or_warn (struct bfd
*abfd
)
638 const char *name
= bfd_get_filename (abfd
);
640 for (asection
*sect
: gdb_bfd_sections (abfd
))
641 free_one_bfd_section (sect
);
643 ret
= bfd_close (abfd
);
646 gdb_bfd_close_warning (name
,
647 bfd_errmsg (bfd_get_error ()));
655 gdb_bfd_ref (struct bfd
*abfd
)
657 struct gdb_bfd_data
*gdata
;
663 std::lock_guard
<std::recursive_mutex
> guard (gdb_bfd_mutex
);
666 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
668 bfd_cache_debug_printf ("Increase reference count on bfd %s (%s)",
669 host_address_to_string (abfd
),
670 bfd_get_filename (abfd
));
678 /* Caching only happens via gdb_bfd_open, so passing nullptr here is
680 gdb_bfd_init_data (abfd
, nullptr);
686 gdb_bfd_unref (struct bfd
*abfd
)
688 struct gdb_bfd_data
*gdata
;
689 struct gdb_bfd_cache_search search
;
696 std::lock_guard
<std::recursive_mutex
> guard (gdb_bfd_mutex
);
699 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
700 gdb_assert (gdata
->refc
>= 1);
705 bfd_cache_debug_printf ("Decrease reference count on bfd %s (%s)",
706 host_address_to_string (abfd
),
707 bfd_get_filename (abfd
));
711 bfd_cache_debug_printf ("Delete final reference count on bfd %s (%s)",
712 host_address_to_string (abfd
),
713 bfd_get_filename (abfd
));
715 archive_bfd
= gdata
->archive_bfd
;
716 search
.filename
= bfd_get_filename (abfd
);
718 if (gdb_bfd_cache
&& search
.filename
)
720 hashval_t hash
= htab_hash_string (search
.filename
);
723 search
.mtime
= gdata
->mtime
;
724 search
.size
= gdata
->size
;
725 search
.inode
= gdata
->inode
;
726 search
.device_id
= gdata
->device_id
;
727 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
,
731 htab_clear_slot (gdb_bfd_cache
, slot
);
735 bfd_set_usrdata (abfd
, NULL
); /* Paranoia. */
737 htab_remove_elt (all_bfds
, abfd
);
739 gdb_bfd_close_or_warn (abfd
);
741 gdb_bfd_unref (archive_bfd
);
744 /* A helper function that returns the section data descriptor
745 associated with SECTION. If no such descriptor exists, a new one
746 is allocated and cleared. */
748 static struct gdb_bfd_section_data
*
749 get_section_descriptor (asection
*section
)
751 struct gdb_bfd_section_data
*result
;
753 result
= (struct gdb_bfd_section_data
*) bfd_section_userdata (section
);
757 result
= ((struct gdb_bfd_section_data
*)
758 bfd_zalloc (section
->owner
, sizeof (*result
)));
759 bfd_set_section_userdata (section
, result
);
768 gdb_bfd_map_section (asection
*sectp
, bfd_size_type
*size
)
771 struct gdb_bfd_section_data
*descriptor
;
774 gdb_assert ((sectp
->flags
& SEC_RELOC
) == 0);
775 gdb_assert (size
!= NULL
);
779 descriptor
= get_section_descriptor (sectp
);
781 /* If the data was already read for this BFD, just reuse it. */
782 if (descriptor
->data
!= NULL
)
786 if (!bfd_is_section_compressed (abfd
, sectp
))
788 /* The page size, used when mmapping. */
792 pagesize
= getpagesize ();
794 /* Only try to mmap sections which are large enough: we don't want
795 to waste space due to fragmentation. */
797 if (bfd_section_size (sectp
) > 4 * pagesize
)
799 descriptor
->size
= bfd_section_size (sectp
);
800 descriptor
->data
= bfd_mmap (abfd
, 0, descriptor
->size
, PROT_READ
,
801 MAP_PRIVATE
, sectp
->filepos
,
802 &descriptor
->map_addr
,
803 &descriptor
->map_len
);
805 if ((caddr_t
)descriptor
->data
!= MAP_FAILED
)
807 #if HAVE_POSIX_MADVISE
808 posix_madvise (descriptor
->map_addr
, descriptor
->map_len
,
809 POSIX_MADV_WILLNEED
);
814 /* On failure, clear out the section data and try again. */
815 memset (descriptor
, 0, sizeof (*descriptor
));
818 #endif /* HAVE_MMAP */
820 /* Handle compressed sections, or ordinary uncompressed sections in
823 descriptor
->size
= bfd_section_size (sectp
);
824 descriptor
->data
= NULL
;
827 if (!bfd_get_full_section_contents (abfd
, sectp
, &data
))
829 warning (_("Can't read data for section '%s' in file '%s'"),
830 bfd_section_name (sectp
),
831 bfd_get_filename (abfd
));
832 /* Set size to 0 to prevent further attempts to read the invalid
837 descriptor
->data
= data
;
840 gdb_assert (descriptor
->data
!= NULL
);
841 *size
= descriptor
->size
;
842 return (const gdb_byte
*) descriptor
->data
;
845 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
846 return 1. Otherwise print a warning and return 0. ABFD seek position is
850 get_file_crc (bfd
*abfd
, unsigned long *file_crc_return
)
852 uint32_t file_crc
= 0;
854 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
856 warning (_("Problem reading \"%s\" for CRC: %s"),
857 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
863 gdb_byte buffer
[8 * 1024];
866 count
= bfd_read (buffer
, sizeof (buffer
), abfd
);
867 if (count
== (bfd_size_type
) -1)
869 warning (_("Problem reading \"%s\" for CRC: %s"),
870 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
875 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
878 *file_crc_return
= file_crc
;
885 gdb_bfd_crc (struct bfd
*abfd
, unsigned long *crc_out
)
887 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
889 if (!gdata
->crc_computed
)
890 gdata
->crc_computed
= get_file_crc (abfd
, &gdata
->crc
);
892 if (gdata
->crc_computed
)
893 *crc_out
= gdata
->crc
;
894 return gdata
->crc_computed
;
902 gdb_bfd_fopen (const char *filename
, const char *target
, const char *mode
,
905 bfd
*result
= bfd_fopen (filename
, target
, mode
, fd
);
907 if (result
!= nullptr)
908 bfd_set_cacheable (result
, 1);
910 return gdb_bfd_ref_ptr::new_reference (result
);
916 gdb_bfd_openr (const char *filename
, const char *target
)
918 bfd
*result
= bfd_openr (filename
, target
);
920 return gdb_bfd_ref_ptr::new_reference (result
);
926 gdb_bfd_openw (const char *filename
, const char *target
)
928 bfd
*result
= bfd_openw (filename
, target
);
930 return gdb_bfd_ref_ptr::new_reference (result
);
936 gdb_bfd_openr_iovec (const char *filename
, const char *target
,
937 gdb_iovec_opener_ftype open_fn
)
939 auto do_open
= [] (bfd
*nbfd
, void *closure
) -> void *
941 auto real_opener
= static_cast<gdb_iovec_opener_ftype
*> (closure
);
942 return (*real_opener
) (nbfd
);
945 auto read_trampoline
= [] (bfd
*nbfd
, void *stream
, void *buf
,
946 file_ptr nbytes
, file_ptr offset
) -> file_ptr
948 gdb_bfd_iovec_base
*obj
= static_cast<gdb_bfd_iovec_base
*> (stream
);
949 return obj
->read (nbfd
, buf
, nbytes
, offset
);
952 auto stat_trampoline
= [] (struct bfd
*abfd
, void *stream
,
953 struct stat
*sb
) -> int
955 gdb_bfd_iovec_base
*obj
= static_cast<gdb_bfd_iovec_base
*> (stream
);
956 return obj
->stat (abfd
, sb
);
959 auto close_trampoline
= [] (struct bfd
*nbfd
, void *stream
) -> int
961 gdb_bfd_iovec_base
*obj
= static_cast<gdb_bfd_iovec_base
*> (stream
);
967 bfd
*result
= bfd_openr_iovec (filename
, target
,
969 read_trampoline
, close_trampoline
,
972 return gdb_bfd_ref_ptr::new_reference (result
);
978 gdb_bfd_mark_parent (bfd
*child
, bfd
*parent
)
980 struct gdb_bfd_data
*gdata
;
983 /* No need to stash the filename here, because we also keep a
984 reference on the parent archive. */
986 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (child
);
987 if (gdata
->archive_bfd
== NULL
)
989 gdata
->archive_bfd
= parent
;
990 gdb_bfd_ref (parent
);
993 gdb_assert (gdata
->archive_bfd
== parent
);
999 gdb_bfd_openr_next_archived_file (bfd
*archive
, bfd
*previous
)
1001 bfd
*result
= bfd_openr_next_archived_file (archive
, previous
);
1004 gdb_bfd_mark_parent (result
, archive
);
1006 return gdb_bfd_ref_ptr (result
);
1009 /* See gdb_bfd.h. */
1012 gdb_bfd_record_inclusion (bfd
*includer
, bfd
*includee
)
1014 struct gdb_bfd_data
*gdata
;
1016 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (includer
);
1017 gdata
->included_bfds
.push_back (gdb_bfd_ref_ptr::new_reference (includee
));
1022 static_assert (ARRAY_SIZE (_bfd_std_section
) == 4);
1024 /* See gdb_bfd.h. */
1027 gdb_bfd_section_index (bfd
*abfd
, asection
*section
)
1029 if (section
== NULL
)
1031 else if (section
== bfd_com_section_ptr
)
1032 return bfd_count_sections (abfd
);
1033 else if (section
== bfd_und_section_ptr
)
1034 return bfd_count_sections (abfd
) + 1;
1035 else if (section
== bfd_abs_section_ptr
)
1036 return bfd_count_sections (abfd
) + 2;
1037 else if (section
== bfd_ind_section_ptr
)
1038 return bfd_count_sections (abfd
) + 3;
1039 return section
->index
;
1042 /* See gdb_bfd.h. */
1045 gdb_bfd_count_sections (bfd
*abfd
)
1047 return bfd_count_sections (abfd
) + 4;
1050 /* See gdb_bfd.h. */
1053 gdb_bfd_requires_relocations (bfd
*abfd
)
1055 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
1057 if (gdata
->relocation_computed
== 0)
1061 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
1062 if ((sect
->flags
& SEC_RELOC
) != 0)
1064 gdata
->needs_relocations
= 1;
1068 gdata
->relocation_computed
= 1;
1071 return gdata
->needs_relocations
;
1074 /* See gdb_bfd.h. */
1077 gdb_bfd_get_full_section_contents (bfd
*abfd
, asection
*section
,
1078 gdb::byte_vector
*contents
)
1080 bfd_size_type section_size
= bfd_section_size (section
);
1082 contents
->resize (section_size
);
1084 return bfd_get_section_contents (abfd
, section
, contents
->data (), 0,
1088 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
1089 #define AMBIGUOUS_MESS2 \
1090 ".\nUse \"set gnutarget format-name\" to specify the format."
1092 /* See gdb_bfd.h. */
1095 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
1099 /* Check if errmsg just need simple return. */
1100 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
1101 return bfd_errmsg (error_tag
);
1103 std::string
ret (bfd_errmsg (error_tag
));
1104 ret
+= AMBIGUOUS_MESS1
;
1106 for (p
= matching
; *p
; p
++)
1111 ret
+= AMBIGUOUS_MESS2
;
1118 /* A callback for htab_traverse that prints a single BFD. */
1121 print_one_bfd (void **slot
, void *data
)
1123 bfd
*abfd
= (struct bfd
*) *slot
;
1124 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
1125 struct ui_out
*uiout
= (struct ui_out
*) data
;
1127 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1128 uiout
->field_signed ("refcount", gdata
->refc
);
1129 uiout
->field_string ("addr", host_address_to_string (abfd
));
1130 uiout
->field_string ("filename", bfd_get_filename (abfd
),
1131 file_name_style
.style ());
1137 /* Implement the 'maint info bfd' command. */
1140 maintenance_info_bfds (const char *arg
, int from_tty
)
1142 struct ui_out
*uiout
= current_uiout
;
1144 ui_out_emit_table
table_emitter (uiout
, 3, -1, "bfds");
1145 uiout
->table_header (10, ui_left
, "refcount", "Refcount");
1146 uiout
->table_header (18, ui_left
, "addr", "Address");
1147 uiout
->table_header (40, ui_left
, "filename", "Filename");
1149 uiout
->table_body ();
1150 htab_traverse (all_bfds
, print_one_bfd
, uiout
);
1153 /* BFD related per-inferior data. */
1155 struct bfd_inferior_data
1157 std::unordered_map
<std::string
, unsigned long> bfd_error_string_counts
;
1160 /* Per-inferior data key. */
1162 static const registry
<inferior
>::key
<bfd_inferior_data
> bfd_inferior_data_key
;
1164 /* Fetch per-inferior BFD data. It always returns a valid pointer to
1165 a bfd_inferior_data struct. */
1167 static struct bfd_inferior_data
*
1168 get_bfd_inferior_data (struct inferior
*inf
)
1170 struct bfd_inferior_data
*data
;
1172 data
= bfd_inferior_data_key
.get (inf
);
1173 if (data
== nullptr)
1174 data
= bfd_inferior_data_key
.emplace (inf
);
1179 /* Increment the BFD error count for STR and return the updated
1182 static unsigned long
1183 increment_bfd_error_count (const std::string
&str
)
1186 std::lock_guard
<std::recursive_mutex
> guard (gdb_bfd_mutex
);
1188 struct bfd_inferior_data
*bid
= get_bfd_inferior_data (current_inferior ());
1190 auto &map
= bid
->bfd_error_string_counts
;
1194 /* A print callback for bfd_print_error. */
1196 static int ATTRIBUTE_PRINTF (2, 0)
1197 print_error_callback (void *stream
, const char *fmt
, ...)
1199 string_file
*file
= (string_file
*) stream
;
1200 size_t in_size
= file
->size ();
1203 file
->vprintf (fmt
, ap
);
1205 return file
->size () - in_size
;
1208 /* Define a BFD error handler which will suppress the printing of
1209 messages which have been printed once already. This is done on a
1210 per-inferior basis. */
1213 gdb_bfd_error_handler (const char *fmt
, va_list ap
)
1216 bfd_print_error (print_error_callback
, &output
, fmt
, ap
);
1217 std::string str
= output
.release ();
1219 if (increment_bfd_error_count (str
) > 1)
1222 warning ("%s", str
.c_str ());
1225 /* See gdb_bfd.h. */
1230 if (bfd_init () == BFD_INIT_MAGIC
)
1233 if (bfd_thread_init (gdb_bfd_lock
, gdb_bfd_unlock
, nullptr))
1238 error (_("fatal error: libbfd ABI mismatch"));
1241 void _initialize_gdb_bfd ();
1243 _initialize_gdb_bfd ()
1245 all_bfds
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
1246 NULL
, xcalloc
, xfree
);
1248 add_cmd ("bfds", class_maintenance
, maintenance_info_bfds
, _("\
1249 List the BFDs that are currently open."),
1250 &maintenanceinfolist
);
1252 add_setshow_boolean_cmd ("bfd-sharing", no_class
,
1254 Set whether gdb will share bfds that appear to be the same file."), _("\
1255 Show whether gdb will share bfds that appear to be the same file."), _("\
1256 When enabled gdb will reuse existing bfds rather than reopening the\n\
1257 same file. To decide if two files are the same then gdb compares the\n\
1258 filename, file size, file modification time, and file inode."),
1261 &maintenance_set_cmdlist
,
1262 &maintenance_show_cmdlist
);
1264 add_setshow_boolean_cmd ("bfd-cache", class_maintenance
,
1266 _("Set bfd cache debugging."),
1267 _("Show bfd cache debugging."),
1269 When non-zero, bfd cache specific debugging is enabled."),
1271 &show_bfd_cache_debug
,
1272 &setdebuglist
, &showdebuglist
);
1274 /* Hook the BFD error/warning handler to limit amount of output. */
1275 bfd_set_error_handler (gdb_bfd_error_handler
);