1 /* Definitions for BFD wrappers used by GDB.
3 Copyright (C) 2011-2020 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 non-zero debugging of the bfd caches is enabled. */
139 static unsigned int debug_bfd_cache
;
141 show_bfd_cache_debug (struct ui_file
*file
, int from_tty
,
142 struct cmd_list_element
*c
, const char *value
)
144 fprintf_filtered (file
, _("BFD cache debugging is %s.\n"), value
);
147 /* The type of an object being looked up in gdb_bfd_cache. We use
148 htab's capability of storing one kind of object (BFD in this case)
149 and using a different sort of object for searching. */
151 struct gdb_bfd_cache_search
154 const char *filename
;
157 /* The file size (in bytes). */
159 /* The inode of the file. */
161 /* The device id of the file. */
165 /* A hash function for BFDs. */
168 hash_bfd (const void *b
)
170 const bfd
*abfd
= (const struct bfd
*) b
;
172 /* It is simplest to just hash the filename. */
173 return htab_hash_string (bfd_get_filename (abfd
));
176 /* An equality function for BFDs. Note that this expects the caller
177 to search using struct gdb_bfd_cache_search only, not BFDs. */
180 eq_bfd (const void *a
, const void *b
)
182 const bfd
*abfd
= (const struct bfd
*) a
;
183 const struct gdb_bfd_cache_search
*s
184 = (const struct gdb_bfd_cache_search
*) b
;
185 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
187 return (gdata
->mtime
== s
->mtime
188 && gdata
->size
== s
->size
189 && gdata
->inode
== s
->inode
190 && gdata
->device_id
== s
->device_id
191 && strcmp (bfd_get_filename (abfd
), s
->filename
) == 0);
197 is_target_filename (const char *name
)
199 return startswith (name
, TARGET_SYSROOT_PREFIX
);
205 gdb_bfd_has_target_filename (struct bfd
*abfd
)
207 return is_target_filename (bfd_get_filename (abfd
));
211 /* Return the system error number corresponding to ERRNUM. */
214 fileio_errno_to_host (int errnum
)
258 case FILEIO_ENAMETOOLONG
:
264 /* bfd_openr_iovec OPEN_CLOSURE data for gdb_bfd_open. */
265 struct gdb_bfd_open_closure
271 /* Wrapper for target_fileio_open suitable for passing as the
272 OPEN_FUNC argument to gdb_bfd_openr_iovec. */
275 gdb_bfd_iovec_fileio_open (struct bfd
*abfd
, void *open_closure
)
277 const char *filename
= bfd_get_filename (abfd
);
278 int fd
, target_errno
;
280 gdb_bfd_open_closure
*oclosure
= (gdb_bfd_open_closure
*) open_closure
;
282 gdb_assert (is_target_filename (filename
));
284 fd
= target_fileio_open (oclosure
->inf
,
285 filename
+ strlen (TARGET_SYSROOT_PREFIX
),
286 FILEIO_O_RDONLY
, 0, oclosure
->warn_if_slow
,
290 errno
= fileio_errno_to_host (target_errno
);
291 bfd_set_error (bfd_error_system_call
);
295 stream
= XCNEW (int);
300 /* Wrapper for target_fileio_pread suitable for passing as the
301 PREAD_FUNC argument to gdb_bfd_openr_iovec. */
304 gdb_bfd_iovec_fileio_pread (struct bfd
*abfd
, void *stream
, void *buf
,
305 file_ptr nbytes
, file_ptr offset
)
307 int fd
= *(int *) stream
;
316 bytes
= target_fileio_pread (fd
, (gdb_byte
*) buf
+ pos
,
317 nbytes
- pos
, offset
+ pos
,
320 /* Success, but no bytes, means end-of-file. */
324 errno
= fileio_errno_to_host (target_errno
);
325 bfd_set_error (bfd_error_system_call
);
335 /* Wrapper for target_fileio_close suitable for passing as the
336 CLOSE_FUNC argument to gdb_bfd_openr_iovec. */
339 gdb_bfd_iovec_fileio_close (struct bfd
*abfd
, void *stream
)
341 int fd
= *(int *) stream
;
346 /* Ignore errors on close. These may happen with remote
347 targets if the connection has already been torn down. */
348 target_fileio_close (fd
, &target_errno
);
350 /* Zero means success. */
354 /* Wrapper for target_fileio_fstat suitable for passing as the
355 STAT_FUNC argument to gdb_bfd_openr_iovec. */
358 gdb_bfd_iovec_fileio_fstat (struct bfd
*abfd
, void *stream
,
361 int fd
= *(int *) stream
;
365 result
= target_fileio_fstat (fd
, sb
, &target_errno
);
368 errno
= fileio_errno_to_host (target_errno
);
369 bfd_set_error (bfd_error_system_call
);
375 /* A helper function to initialize the data that gdb attaches to each
379 gdb_bfd_init_data (struct bfd
*abfd
, struct stat
*st
)
381 struct gdb_bfd_data
*gdata
;
384 gdb_assert (bfd_usrdata (abfd
) == nullptr);
386 /* Ask BFD to decompress sections in bfd_get_full_section_contents. */
387 abfd
->flags
|= BFD_DECOMPRESS
;
389 gdata
= new gdb_bfd_data (abfd
, st
);
390 bfd_set_usrdata (abfd
, gdata
);
391 bfd_alloc_data (abfd
);
393 /* This is the first we've seen it, so add it to the hash table. */
394 slot
= htab_find_slot (all_bfds
, abfd
, INSERT
);
395 gdb_assert (slot
&& !*slot
);
402 gdb_bfd_open (const char *name
, const char *target
, int fd
,
408 struct gdb_bfd_cache_search search
;
411 if (is_target_filename (name
))
413 if (!target_filesystem_is_local ())
415 gdb_assert (fd
== -1);
417 gdb_bfd_open_closure open_closure
{ current_inferior (), warn_if_slow
};
418 return gdb_bfd_openr_iovec (name
, target
,
419 gdb_bfd_iovec_fileio_open
,
421 gdb_bfd_iovec_fileio_pread
,
422 gdb_bfd_iovec_fileio_close
,
423 gdb_bfd_iovec_fileio_fstat
);
426 name
+= strlen (TARGET_SYSROOT_PREFIX
);
429 if (gdb_bfd_cache
== NULL
)
430 gdb_bfd_cache
= htab_create_alloc (1, hash_bfd
, eq_bfd
, NULL
,
435 fd
= gdb_open_cloexec (name
, O_RDONLY
| O_BINARY
, 0);
438 bfd_set_error (bfd_error_system_call
);
443 if (fstat (fd
, &st
) < 0)
445 /* Weird situation here -- don't cache if we can't stat. */
447 fprintf_unfiltered (gdb_stdlog
,
448 "Could not stat %s - not caching\n",
450 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
453 return gdb_bfd_ref_ptr::new_reference (abfd
);
456 search
.filename
= name
;
457 search
.mtime
= st
.st_mtime
;
458 search
.size
= st
.st_size
;
459 search
.inode
= st
.st_ino
;
460 search
.device_id
= st
.st_dev
;
462 /* Note that this must compute the same result as hash_bfd. */
463 hash
= htab_hash_string (name
);
464 /* Note that we cannot use htab_find_slot_with_hash here, because
465 opening the BFD may fail; and this would violate hashtab
467 abfd
= (struct bfd
*) htab_find_with_hash (gdb_bfd_cache
, &search
, hash
);
468 if (bfd_sharing
&& abfd
!= NULL
)
471 fprintf_unfiltered (gdb_stdlog
,
472 "Reusing cached bfd %s for %s\n",
473 host_address_to_string (abfd
),
474 bfd_get_filename (abfd
));
476 return gdb_bfd_ref_ptr::new_reference (abfd
);
479 abfd
= bfd_fopen (name
, target
, FOPEN_RB
, fd
);
484 fprintf_unfiltered (gdb_stdlog
,
485 "Creating new bfd %s for %s\n",
486 host_address_to_string (abfd
),
487 bfd_get_filename (abfd
));
491 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
, INSERT
);
496 /* It's important to pass the already-computed stat info here,
497 rather than, say, calling gdb_bfd_ref_ptr::new_reference. BFD by
498 default will "stat" the file each time bfd_get_mtime is called --
499 and since we already entered it into the hash table using this
500 mtime, if the file changed at the wrong moment, the race would
501 lead to a hash table corruption. */
502 gdb_bfd_init_data (abfd
, &st
);
503 return gdb_bfd_ref_ptr (abfd
);
506 /* A helper function that releases any section data attached to the
510 free_one_bfd_section (bfd
*abfd
, asection
*sectp
, void *ignore
)
512 struct gdb_bfd_section_data
*sect
513 = (struct gdb_bfd_section_data
*) bfd_section_userdata (sectp
);
515 if (sect
!= NULL
&& sect
->data
!= NULL
)
518 if (sect
->map_addr
!= NULL
)
522 res
= munmap (sect
->map_addr
, sect
->map_len
);
523 gdb_assert (res
== 0);
531 /* Close ABFD, and warn if that fails. */
534 gdb_bfd_close_or_warn (struct bfd
*abfd
)
537 const char *name
= bfd_get_filename (abfd
);
539 bfd_map_over_sections (abfd
, free_one_bfd_section
, NULL
);
541 ret
= bfd_close (abfd
);
544 warning (_("cannot close \"%s\": %s"),
545 name
, bfd_errmsg (bfd_get_error ()));
553 gdb_bfd_ref (struct bfd
*abfd
)
555 struct gdb_bfd_data
*gdata
;
560 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
563 fprintf_unfiltered (gdb_stdlog
,
564 "Increase reference count on bfd %s (%s)\n",
565 host_address_to_string (abfd
),
566 bfd_get_filename (abfd
));
574 /* Caching only happens via gdb_bfd_open, so passing nullptr here is
576 gdb_bfd_init_data (abfd
, nullptr);
582 gdb_bfd_unref (struct bfd
*abfd
)
584 struct gdb_bfd_data
*gdata
;
585 struct gdb_bfd_cache_search search
;
591 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
592 gdb_assert (gdata
->refc
>= 1);
598 fprintf_unfiltered (gdb_stdlog
,
599 "Decrease reference count on bfd %s (%s)\n",
600 host_address_to_string (abfd
),
601 bfd_get_filename (abfd
));
606 fprintf_unfiltered (gdb_stdlog
,
607 "Delete final reference count on bfd %s (%s)\n",
608 host_address_to_string (abfd
),
609 bfd_get_filename (abfd
));
611 archive_bfd
= gdata
->archive_bfd
;
612 search
.filename
= bfd_get_filename (abfd
);
614 if (gdb_bfd_cache
&& search
.filename
)
616 hashval_t hash
= htab_hash_string (search
.filename
);
619 search
.mtime
= gdata
->mtime
;
620 search
.size
= gdata
->size
;
621 search
.inode
= gdata
->inode
;
622 search
.device_id
= gdata
->device_id
;
623 slot
= htab_find_slot_with_hash (gdb_bfd_cache
, &search
, hash
,
627 htab_clear_slot (gdb_bfd_cache
, slot
);
630 bfd_free_data (abfd
);
632 bfd_set_usrdata (abfd
, NULL
); /* Paranoia. */
634 htab_remove_elt (all_bfds
, abfd
);
636 gdb_bfd_close_or_warn (abfd
);
638 gdb_bfd_unref (archive_bfd
);
641 /* A helper function that returns the section data descriptor
642 associated with SECTION. If no such descriptor exists, a new one
643 is allocated and cleared. */
645 static struct gdb_bfd_section_data
*
646 get_section_descriptor (asection
*section
)
648 struct gdb_bfd_section_data
*result
;
650 result
= (struct gdb_bfd_section_data
*) bfd_section_userdata (section
);
654 result
= ((struct gdb_bfd_section_data
*)
655 bfd_zalloc (section
->owner
, sizeof (*result
)));
656 bfd_set_section_userdata (section
, result
);
665 gdb_bfd_map_section (asection
*sectp
, bfd_size_type
*size
)
668 struct gdb_bfd_section_data
*descriptor
;
671 gdb_assert ((sectp
->flags
& SEC_RELOC
) == 0);
672 gdb_assert (size
!= NULL
);
676 descriptor
= get_section_descriptor (sectp
);
678 /* If the data was already read for this BFD, just reuse it. */
679 if (descriptor
->data
!= NULL
)
683 if (!bfd_is_section_compressed (abfd
, sectp
))
685 /* The page size, used when mmapping. */
689 pagesize
= getpagesize ();
691 /* Only try to mmap sections which are large enough: we don't want
692 to waste space due to fragmentation. */
694 if (bfd_section_size (sectp
) > 4 * pagesize
)
696 descriptor
->size
= bfd_section_size (sectp
);
697 descriptor
->data
= bfd_mmap (abfd
, 0, descriptor
->size
, PROT_READ
,
698 MAP_PRIVATE
, sectp
->filepos
,
699 &descriptor
->map_addr
,
700 &descriptor
->map_len
);
702 if ((caddr_t
)descriptor
->data
!= MAP_FAILED
)
704 #if HAVE_POSIX_MADVISE
705 posix_madvise (descriptor
->map_addr
, descriptor
->map_len
,
706 POSIX_MADV_WILLNEED
);
711 /* On failure, clear out the section data and try again. */
712 memset (descriptor
, 0, sizeof (*descriptor
));
715 #endif /* HAVE_MMAP */
717 /* Handle compressed sections, or ordinary uncompressed sections in
720 descriptor
->size
= bfd_section_size (sectp
);
721 descriptor
->data
= NULL
;
724 if (!bfd_get_full_section_contents (abfd
, sectp
, &data
))
726 warning (_("Can't read data for section '%s' in file '%s'"),
727 bfd_section_name (sectp
),
728 bfd_get_filename (abfd
));
729 /* Set size to 0 to prevent further attempts to read the invalid
734 descriptor
->data
= data
;
737 gdb_assert (descriptor
->data
!= NULL
);
738 *size
= descriptor
->size
;
739 return (const gdb_byte
*) descriptor
->data
;
742 /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
743 return 1. Otherwise print a warning and return 0. ABFD seek position is
747 get_file_crc (bfd
*abfd
, unsigned long *file_crc_return
)
749 unsigned long file_crc
= 0;
751 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0)
753 warning (_("Problem reading \"%s\" for CRC: %s"),
754 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
760 gdb_byte buffer
[8 * 1024];
763 count
= bfd_bread (buffer
, sizeof (buffer
), abfd
);
764 if (count
== (bfd_size_type
) -1)
766 warning (_("Problem reading \"%s\" for CRC: %s"),
767 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
772 file_crc
= bfd_calc_gnu_debuglink_crc32 (file_crc
, buffer
, count
);
775 *file_crc_return
= file_crc
;
782 gdb_bfd_crc (struct bfd
*abfd
, unsigned long *crc_out
)
784 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
786 if (!gdata
->crc_computed
)
787 gdata
->crc_computed
= get_file_crc (abfd
, &gdata
->crc
);
789 if (gdata
->crc_computed
)
790 *crc_out
= gdata
->crc
;
791 return gdata
->crc_computed
;
799 gdb_bfd_fopen (const char *filename
, const char *target
, const char *mode
,
802 bfd
*result
= bfd_fopen (filename
, target
, mode
, fd
);
804 return gdb_bfd_ref_ptr::new_reference (result
);
810 gdb_bfd_openr (const char *filename
, const char *target
)
812 bfd
*result
= bfd_openr (filename
, target
);
814 return gdb_bfd_ref_ptr::new_reference (result
);
820 gdb_bfd_openw (const char *filename
, const char *target
)
822 bfd
*result
= bfd_openw (filename
, target
);
824 return gdb_bfd_ref_ptr::new_reference (result
);
830 gdb_bfd_openr_iovec (const char *filename
, const char *target
,
831 void *(*open_func
) (struct bfd
*nbfd
,
834 file_ptr (*pread_func
) (struct bfd
*nbfd
,
839 int (*close_func
) (struct bfd
*nbfd
,
841 int (*stat_func
) (struct bfd
*abfd
,
845 bfd
*result
= bfd_openr_iovec (filename
, target
,
846 open_func
, open_closure
,
847 pread_func
, close_func
, stat_func
);
849 return gdb_bfd_ref_ptr::new_reference (result
);
855 gdb_bfd_mark_parent (bfd
*child
, bfd
*parent
)
857 struct gdb_bfd_data
*gdata
;
860 /* No need to stash the filename here, because we also keep a
861 reference on the parent archive. */
863 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (child
);
864 if (gdata
->archive_bfd
== NULL
)
866 gdata
->archive_bfd
= parent
;
867 gdb_bfd_ref (parent
);
870 gdb_assert (gdata
->archive_bfd
== parent
);
876 gdb_bfd_openr_next_archived_file (bfd
*archive
, bfd
*previous
)
878 bfd
*result
= bfd_openr_next_archived_file (archive
, previous
);
881 gdb_bfd_mark_parent (result
, archive
);
883 return gdb_bfd_ref_ptr (result
);
889 gdb_bfd_record_inclusion (bfd
*includer
, bfd
*includee
)
891 struct gdb_bfd_data
*gdata
;
893 gdata
= (struct gdb_bfd_data
*) bfd_usrdata (includer
);
894 gdata
->included_bfds
.push_back (gdb_bfd_ref_ptr::new_reference (includee
));
899 gdb_static_assert (ARRAY_SIZE (_bfd_std_section
) == 4);
904 gdb_bfd_section_index (bfd
*abfd
, asection
*section
)
908 else if (section
== bfd_com_section_ptr
)
909 return bfd_count_sections (abfd
);
910 else if (section
== bfd_und_section_ptr
)
911 return bfd_count_sections (abfd
) + 1;
912 else if (section
== bfd_abs_section_ptr
)
913 return bfd_count_sections (abfd
) + 2;
914 else if (section
== bfd_ind_section_ptr
)
915 return bfd_count_sections (abfd
) + 3;
916 return section
->index
;
922 gdb_bfd_count_sections (bfd
*abfd
)
924 return bfd_count_sections (abfd
) + 4;
930 gdb_bfd_requires_relocations (bfd
*abfd
)
932 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
934 if (gdata
->relocation_computed
== 0)
938 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
939 if ((sect
->flags
& SEC_RELOC
) != 0)
941 gdata
->needs_relocations
= 1;
945 gdata
->relocation_computed
= 1;
948 return gdata
->needs_relocations
;
954 gdb_bfd_get_full_section_contents (bfd
*abfd
, asection
*section
,
955 gdb::byte_vector
*contents
)
957 bfd_size_type section_size
= bfd_section_size (section
);
959 contents
->resize (section_size
);
961 return bfd_get_section_contents (abfd
, section
, contents
->data (), 0,
965 /* A callback for htab_traverse that prints a single BFD. */
968 print_one_bfd (void **slot
, void *data
)
970 bfd
*abfd
= (struct bfd
*) *slot
;
971 struct gdb_bfd_data
*gdata
= (struct gdb_bfd_data
*) bfd_usrdata (abfd
);
972 struct ui_out
*uiout
= (struct ui_out
*) data
;
974 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
975 uiout
->field_signed ("refcount", gdata
->refc
);
976 uiout
->field_string ("addr", host_address_to_string (abfd
));
977 uiout
->field_string ("filename", bfd_get_filename (abfd
));
983 /* Implement the 'maint info bfd' command. */
986 maintenance_info_bfds (const char *arg
, int from_tty
)
988 struct ui_out
*uiout
= current_uiout
;
990 ui_out_emit_table
table_emitter (uiout
, 3, -1, "bfds");
991 uiout
->table_header (10, ui_left
, "refcount", "Refcount");
992 uiout
->table_header (18, ui_left
, "addr", "Address");
993 uiout
->table_header (40, ui_left
, "filename", "Filename");
995 uiout
->table_body ();
996 htab_traverse (all_bfds
, print_one_bfd
, uiout
);
999 void _initialize_gdb_bfd ();
1001 _initialize_gdb_bfd ()
1003 all_bfds
= htab_create_alloc (10, htab_hash_pointer
, htab_eq_pointer
,
1004 NULL
, xcalloc
, xfree
);
1006 add_cmd ("bfds", class_maintenance
, maintenance_info_bfds
, _("\
1007 List the BFDs that are currently open."),
1008 &maintenanceinfolist
);
1010 add_setshow_boolean_cmd ("bfd-sharing", no_class
,
1012 Set whether gdb will share bfds that appear to be the same file."), _("\
1013 Show whether gdb will share bfds that appear to be the same file."), _("\
1014 When enabled gdb will reuse existing bfds rather than reopening the\n\
1015 same file. To decide if two files are the same then gdb compares the\n\
1016 filename, file size, file modification time, and file inode."),
1019 &maintenance_set_cmdlist
,
1020 &maintenance_show_cmdlist
);
1022 add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance
,
1023 &debug_bfd_cache
, _("\
1024 Set bfd cache debugging."), _("\
1025 Show bfd cache debugging."), _("\
1026 When non-zero, bfd cache specific debugging is enabled."),
1028 &show_bfd_cache_debug
,
1029 &setdebuglist
, &showdebuglist
);