1 /* Definitions for BFD wrappers used by GDB.
3 Copyright (C) 2011-2022 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 /* Warn that it wasn't possible to close a bfd for file NAME, because
430 gdb_bfd_close_warning (const char *name
, const char *reason
)
432 warning (_("cannot close \"%s\": %s"), name
, reason
);
435 /* Wrapper for target_fileio_close suitable for passing as the
436 CLOSE_FUNC argument to gdb_bfd_openr_iovec. */
439 gdb_bfd_iovec_fileio_close (struct bfd
*abfd
, void *stream
)
441 int fd
= *(int *) stream
;
446 /* Ignore errors on close. These may happen with remote
447 targets if the connection has already been torn down. */
450 target_fileio_close (fd
, &target_errno
);
452 catch (const gdb_exception
&ex
)
454 /* Also avoid crossing exceptions over bfd. */
455 gdb_bfd_close_warning (bfd_get_filename (abfd
),
456 ex
.message
->c_str ());
459 /* Zero means success. */
463 /* Wrapper for target_fileio_fstat suitable for passing as the
464 STAT_FUNC argument to gdb_bfd_openr_iovec. */
467 gdb_bfd_iovec_fileio_fstat (struct bfd
*abfd
, void *stream
,
470 int fd
= *(int *) stream
;
474 result
= target_fileio_fstat (fd
, sb
, &target_errno
);
477 errno
= fileio_errno_to_host (target_errno
);
478 bfd_set_error (bfd_error_system_call
);
484 /* A helper function to initialize the data that gdb attaches to each
488 gdb_bfd_init_data (struct bfd
*abfd
, struct stat
*st
)
490 struct gdb_bfd_data
*gdata
;
493 gdb_assert (bfd_usrdata (abfd
) == nullptr);
495 /* Ask BFD to decompress sections in bfd_get_full_section_contents. */
496 abfd
->flags
|= BFD_DECOMPRESS
;
498 gdata
= new gdb_bfd_data (abfd
, st
);
499 bfd_set_usrdata (abfd
, gdata
);
500 bfd_alloc_data (abfd
);
502 /* This is the first we've seen it, so add it to the hash table. */
503 slot
= htab_find_slot (all_bfds
, abfd
, INSERT
);
504 gdb_assert (slot
&& !*slot
);
511 gdb_bfd_open (const char *name
, const char *target
, int fd
,
517 struct gdb_bfd_cache_search search
;
520 if (is_target_filename (name
))
522 if (!target_filesystem_is_local ())
524 gdb_assert (fd
== -1);
526 gdb_bfd_open_closure open_closure
{ current_inferior (), warn_if_slow
};
527 return gdb_bfd_openr_iovec (name
, target
,
528 gdb_bfd_iovec_fileio_open
,
530 gdb_bfd_iovec_fileio_pread
,
531 gdb_bfd_iovec_fileio_close
,
532 gdb_bfd_iovec_fileio_fstat
);
535 name
+= strlen (TARGET_SYSROOT_PREFIX
);
538 if (gdb_bfd_cache
== NULL
)
539 gdb_bfd_cache
= htab_create_alloc (1, hash_bfd
, eq_bfd
, NULL
,
544 fd
= gdb_open_cloexec (name
, O_RDONLY
| O_BINARY
, 0).release ();
547 bfd_set_error (bfd_error_system_call
);
552 if (fstat (fd
, &st
) < 0)
554 /* Weird situation here -- don't cache if we can't stat. */
555 bfd_cache_debug_printf ("Could not stat %s - not caching", name
);
556 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
559 return gdb_bfd_ref_ptr::new_reference (abfd
);
562 search
.filename
= name
;
563 search
.mtime
= st
.st_mtime
;
564 search
.size
= st
.st_size
;
565 search
.inode
= st
.st_ino
;
566 search
.device_id
= st
.st_dev
;
568 /* Note that this must compute the same result as hash_bfd. */
569 hash
= htab_hash_string (name
);
570 /* Note that we cannot use htab_find_slot_with_hash here, because
571 opening the BFD may fail; and this would violate hashtab
573 abfd
= (struct bfd
*) htab_find_with_hash (gdb_bfd_cache
, &search
, hash
);
574 if (bfd_sharing
&& abfd
!= NULL
)
576 bfd_cache_debug_printf ("Reusing cached bfd %s for %s",
577 host_address_to_string (abfd
),
578 bfd_get_filename (abfd
));
580 return gdb_bfd_ref_ptr::new_reference (abfd
);
583 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
587 bfd_cache_debug_printf ("Creating new bfd %s for %s",
588 host_address_to_string (abfd
),
589 bfd_get_filename (abfd
));
593 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
, INSERT
);
598 /* It's important to pass the already-computed stat info here,
599 rather than, say, calling gdb_bfd_ref_ptr::new_reference. BFD by
600 default will "stat" the file each time bfd_get_mtime is called --
601 and since we already entered it into the hash table using this
602 mtime, if the file changed at the wrong moment, the race would
603 lead to a hash table corruption. */
604 gdb_bfd_init_data (abfd
, &st
);
605 return gdb_bfd_ref_ptr (abfd
);
608 /* A helper function that releases any section data attached to the
612 free_one_bfd_section (asection
*sectp
)
614 struct gdb_bfd_section_data
*sect
615 = (struct gdb_bfd_section_data
*) bfd_section_userdata (sectp
);
617 if (sect
!= NULL
&& sect
->data
!= NULL
)
620 if (sect
->map_addr
!= NULL
)
624 res
= munmap (sect
->map_addr
, sect
->map_len
);
625 gdb_assert (res
== 0);
633 /* Close ABFD, and warn if that fails. */
636 gdb_bfd_close_or_warn (struct bfd
*abfd
)
639 const char *name
= bfd_get_filename (abfd
);
641 for (asection
*sect
: gdb_bfd_sections (abfd
))
642 free_one_bfd_section (sect
);
644 ret
= bfd_close (abfd
);
647 gdb_bfd_close_warning (name
,
648 bfd_errmsg (bfd_get_error ()));
656 gdb_bfd_ref (struct bfd
*abfd
)
658 struct gdb_bfd_data
*gdata
;
663 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
665 bfd_cache_debug_printf ("Increase reference count on bfd %s (%s)",
666 host_address_to_string (abfd
),
667 bfd_get_filename (abfd
));
675 /* Caching only happens via gdb_bfd_open, so passing nullptr here is
677 gdb_bfd_init_data (abfd
, nullptr);
683 gdb_bfd_unref (struct bfd
*abfd
)
685 struct gdb_bfd_data
*gdata
;
686 struct gdb_bfd_cache_search search
;
692 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
693 gdb_assert (gdata
->refc
>= 1);
698 bfd_cache_debug_printf ("Decrease reference count on bfd %s (%s)",
699 host_address_to_string (abfd
),
700 bfd_get_filename (abfd
));
704 bfd_cache_debug_printf ("Delete final reference count on bfd %s (%s)",
705 host_address_to_string (abfd
),
706 bfd_get_filename (abfd
));
708 archive_bfd
= gdata
->archive_bfd
;
709 search
.filename
= bfd_get_filename (abfd
);
711 if (gdb_bfd_cache
&& search
.filename
)
713 hashval_t hash
= htab_hash_string (search
.filename
);
716 search
.mtime
= gdata
->mtime
;
717 search
.size
= gdata
->size
;
718 search
.inode
= gdata
->inode
;
719 search
.device_id
= gdata
->device_id
;
720 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
,
724 htab_clear_slot (gdb_bfd_cache
, slot
);
727 bfd_free_data (abfd
);
729 bfd_set_usrdata (abfd
, NULL
); /* Paranoia. */
731 htab_remove_elt (all_bfds
, abfd
);
733 gdb_bfd_close_or_warn (abfd
);
735 gdb_bfd_unref (archive_bfd
);
738 /* A helper function that returns the section data descriptor
739 associated with SECTION. If no such descriptor exists, a new one
740 is allocated and cleared. */
742 static struct gdb_bfd_section_data
*
743 get_section_descriptor (asection
*section
)
745 struct gdb_bfd_section_data
*result
;
747 result
= (struct gdb_bfd_section_data
*) bfd_section_userdata (section
);
751 result
= ((struct gdb_bfd_section_data
*)
752 bfd_zalloc (section
->owner
, sizeof (*result
)));
753 bfd_set_section_userdata (section
, result
);
762 gdb_bfd_map_section (asection
*sectp
, bfd_size_type
*size
)
765 struct gdb_bfd_section_data
*descriptor
;
768 gdb_assert ((sectp
->flags
& SEC_RELOC
) == 0);
769 gdb_assert (size
!= NULL
);
773 descriptor
= get_section_descriptor (sectp
);
775 /* If the data was already read for this BFD, just reuse it. */
776 if (descriptor
->data
!= NULL
)
780 if (!bfd_is_section_compressed (abfd
, sectp
))
782 /* The page size, used when mmapping. */
786 pagesize
= getpagesize ();
788 /* Only try to mmap sections which are large enough: we don't want
789 to waste space due to fragmentation. */
791 if (bfd_section_size (sectp
) > 4 * pagesize
)
793 descriptor
->size
= bfd_section_size (sectp
);
794 descriptor
->data
= bfd_mmap (abfd
, 0, descriptor
->size
, PROT_READ
,
795 MAP_PRIVATE
, sectp
->filepos
,
796 &descriptor
->map_addr
,
797 &descriptor
->map_len
);
799 if ((caddr_t
)descriptor
->data
!= MAP_FAILED
)
801 #if HAVE_POSIX_MADVISE
802 posix_madvise (descriptor
->map_addr
, descriptor
->map_len
,
803 POSIX_MADV_WILLNEED
);
808 /* On failure, clear out the section data and try again. */
809 memset (descriptor
, 0, sizeof (*descriptor
));
812 #endif /* HAVE_MMAP */
814 /* Handle compressed sections, or ordinary uncompressed sections in
817 descriptor
->size
= bfd_section_size (sectp
);
818 descriptor
->data
= NULL
;
821 if (!bfd_get_full_section_contents (abfd
, sectp
, &data
))
823 warning (_("Can't read data for section '%s' in file '%s'"),
824 bfd_section_name (sectp
),
825 bfd_get_filename (abfd
));
826 /* Set size to 0 to prevent further attempts to read the invalid
831 descriptor
->data
= data
;
834 gdb_assert (descriptor
->data
!= NULL
);
835 *size
= descriptor
->size
;
836 return (const gdb_byte
*) descriptor
->data
;
839 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
840 return 1. Otherwise print a warning and return 0. ABFD seek position is
844 get_file_crc (bfd
*abfd
, unsigned long *file_crc_return
)
846 unsigned long file_crc
= 0;
848 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
850 warning (_("Problem reading \"%s\" for CRC: %s"),
851 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
857 gdb_byte buffer
[8 * 1024];
860 count
= bfd_bread (buffer
, sizeof (buffer
), abfd
);
861 if (count
== (bfd_size_type
) -1)
863 warning (_("Problem reading \"%s\" for CRC: %s"),
864 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
869 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
872 *file_crc_return
= file_crc
;
879 gdb_bfd_crc (struct bfd
*abfd
, unsigned long *crc_out
)
881 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
883 if (!gdata
->crc_computed
)
884 gdata
->crc_computed
= get_file_crc (abfd
, &gdata
->crc
);
886 if (gdata
->crc_computed
)
887 *crc_out
= gdata
->crc
;
888 return gdata
->crc_computed
;
896 gdb_bfd_fopen (const char *filename
, const char *target
, const char *mode
,
899 bfd
*result
= bfd_fopen (filename
, target
, mode
, fd
);
901 return gdb_bfd_ref_ptr::new_reference (result
);
907 gdb_bfd_openr (const char *filename
, const char *target
)
909 bfd
*result
= bfd_openr (filename
, target
);
911 return gdb_bfd_ref_ptr::new_reference (result
);
917 gdb_bfd_openw (const char *filename
, const char *target
)
919 bfd
*result
= bfd_openw (filename
, target
);
921 return gdb_bfd_ref_ptr::new_reference (result
);
927 gdb_bfd_openr_iovec (const char *filename
, const char *target
,
928 void *(*open_func
) (struct bfd
*nbfd
,
931 file_ptr (*pread_func
) (struct bfd
*nbfd
,
936 int (*close_func
) (struct bfd
*nbfd
,
938 int (*stat_func
) (struct bfd
*abfd
,
942 bfd
*result
= bfd_openr_iovec (filename
, target
,
943 open_func
, open_closure
,
944 pread_func
, close_func
, stat_func
);
946 return gdb_bfd_ref_ptr::new_reference (result
);
952 gdb_bfd_mark_parent (bfd
*child
, bfd
*parent
)
954 struct gdb_bfd_data
*gdata
;
957 /* No need to stash the filename here, because we also keep a
958 reference on the parent archive. */
960 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (child
);
961 if (gdata
->archive_bfd
== NULL
)
963 gdata
->archive_bfd
= parent
;
964 gdb_bfd_ref (parent
);
967 gdb_assert (gdata
->archive_bfd
== parent
);
973 gdb_bfd_openr_next_archived_file (bfd
*archive
, bfd
*previous
)
975 bfd
*result
= bfd_openr_next_archived_file (archive
, previous
);
978 gdb_bfd_mark_parent (result
, archive
);
980 return gdb_bfd_ref_ptr (result
);
986 gdb_bfd_record_inclusion (bfd
*includer
, bfd
*includee
)
988 struct gdb_bfd_data
*gdata
;
990 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (includer
);
991 gdata
->included_bfds
.push_back (gdb_bfd_ref_ptr::new_reference (includee
));
996 gdb_static_assert (ARRAY_SIZE (_bfd_std_section
) == 4);
1001 gdb_bfd_section_index (bfd
*abfd
, asection
*section
)
1003 if (section
== NULL
)
1005 else if (section
== bfd_com_section_ptr
)
1006 return bfd_count_sections (abfd
);
1007 else if (section
== bfd_und_section_ptr
)
1008 return bfd_count_sections (abfd
) + 1;
1009 else if (section
== bfd_abs_section_ptr
)
1010 return bfd_count_sections (abfd
) + 2;
1011 else if (section
== bfd_ind_section_ptr
)
1012 return bfd_count_sections (abfd
) + 3;
1013 return section
->index
;
1016 /* See gdb_bfd.h. */
1019 gdb_bfd_count_sections (bfd
*abfd
)
1021 return bfd_count_sections (abfd
) + 4;
1024 /* See gdb_bfd.h. */
1027 gdb_bfd_requires_relocations (bfd
*abfd
)
1029 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
1031 if (gdata
->relocation_computed
== 0)
1035 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
1036 if ((sect
->flags
& SEC_RELOC
) != 0)
1038 gdata
->needs_relocations
= 1;
1042 gdata
->relocation_computed
= 1;
1045 return gdata
->needs_relocations
;
1048 /* See gdb_bfd.h. */
1051 gdb_bfd_get_full_section_contents (bfd
*abfd
, asection
*section
,
1052 gdb::byte_vector
*contents
)
1054 bfd_size_type section_size
= bfd_section_size (section
);
1056 contents
->resize (section_size
);
1058 return bfd_get_section_contents (abfd
, section
, contents
->data (), 0,
1062 #define AMBIGUOUS_MESS1 ".\nMatching formats:"
1063 #define AMBIGUOUS_MESS2 \
1064 ".\nUse \"set gnutarget format-name\" to specify the format."
1066 /* See gdb_bfd.h. */
1069 gdb_bfd_errmsg (bfd_error_type error_tag
, char **matching
)
1073 /* Check if errmsg just need simple return. */
1074 if (error_tag
!= bfd_error_file_ambiguously_recognized
|| matching
== NULL
)
1075 return bfd_errmsg (error_tag
);
1077 std::string
ret (bfd_errmsg (error_tag
));
1078 ret
+= AMBIGUOUS_MESS1
;
1080 for (p
= matching
; *p
; p
++)
1085 ret
+= AMBIGUOUS_MESS2
;
1092 /* A callback for htab_traverse that prints a single BFD. */
1095 print_one_bfd (void **slot
, void *data
)
1097 bfd
*abfd
= (struct bfd
*) *slot
;
1098 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
1099 struct ui_out
*uiout
= (struct ui_out
*) data
;
1101 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1102 uiout
->field_signed ("refcount", gdata
->refc
);
1103 uiout
->field_string ("addr", host_address_to_string (abfd
));
1104 uiout
->field_string ("filename", bfd_get_filename (abfd
));
1110 /* Implement the 'maint info bfd' command. */
1113 maintenance_info_bfds (const char *arg
, int from_tty
)
1115 struct ui_out
*uiout
= current_uiout
;
1117 ui_out_emit_table
table_emitter (uiout
, 3, -1, "bfds");
1118 uiout
->table_header (10, ui_left
, "refcount", "Refcount");
1119 uiout
->table_header (18, ui_left
, "addr", "Address");
1120 uiout
->table_header (40, ui_left
, "filename", "Filename");
1122 uiout
->table_body ();
1123 htab_traverse (all_bfds
, print_one_bfd
, uiout
);
1126 void _initialize_gdb_bfd ();
1128 _initialize_gdb_bfd ()
1130 all_bfds
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
1131 NULL
, xcalloc
, xfree
);
1133 add_cmd ("bfds", class_maintenance
, maintenance_info_bfds
, _("\
1134 List the BFDs that are currently open."),
1135 &maintenanceinfolist
);
1137 add_setshow_boolean_cmd ("bfd-sharing", no_class
,
1139 Set whether gdb will share bfds that appear to be the same file."), _("\
1140 Show whether gdb will share bfds that appear to be the same file."), _("\
1141 When enabled gdb will reuse existing bfds rather than reopening the\n\
1142 same file. To decide if two files are the same then gdb compares the\n\
1143 filename, file size, file modification time, and file inode."),
1146 &maintenance_set_cmdlist
,
1147 &maintenance_show_cmdlist
);
1149 add_setshow_boolean_cmd ("bfd-cache", class_maintenance
,
1151 _("Set bfd cache debugging."),
1152 _("Show bfd cache debugging."),
1154 When non-zero, bfd cache specific debugging is enabled."),
1156 &show_bfd_cache_debug
,
1157 &setdebuglist
, &showdebuglist
);