X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdb_bfd.c;h=c82191ee97b133dc6d1c5d4390a732f85ff1d936;hb=75c6c844d9df37761e0e834df057b89e41816e55;hp=7543dae0b2f02df7984cefccb8fce48824a34626;hpb=32d0add0a654c1204ab71dc8a55d9374538c4b33;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdb_bfd.c b/gdb/gdb_bfd.c index 7543dae0b2..c82191ee97 100644 --- a/gdb/gdb_bfd.c +++ b/gdb/gdb_bfd.c @@ -1,6 +1,6 @@ /* Definitions for BFD wrappers used by GDB. - Copyright (C) 2011-2015 Free Software Foundation, Inc. + Copyright (C) 2011-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -22,20 +22,16 @@ #include "ui-out.h" #include "gdbcmd.h" #include "hashtab.h" -#include "filestuff.h" -#include "vec.h" -#ifdef HAVE_ZLIB_H -#include -#endif +#include "gdbsupport/filestuff.h" #ifdef HAVE_MMAP #include #ifndef MAP_FAILED #define MAP_FAILED ((void *) -1) #endif #endif - -typedef bfd *bfdp; -DEF_VEC_P (bfdp); +#include "target.h" +#include "gdb/fileio.h" +#include "inferior.h" /* An object of this type is stored in the section's user data when mapping a section. */ @@ -63,12 +59,47 @@ static htab_t all_bfds; struct gdb_bfd_data { + gdb_bfd_data (bfd *abfd) + : mtime (bfd_get_mtime (abfd)), + size (bfd_get_size (abfd)), + relocation_computed (0), + needs_relocations (0), + crc_computed (0) + { + struct stat buf; + + if (bfd_stat (abfd, &buf) == 0) + { + inode = buf.st_ino; + device_id = buf.st_dev; + } + else + { + /* The stat failed. */ + inode = 0; + device_id = 0; + } + } + + ~gdb_bfd_data () + { + } + /* The reference count. */ - int refc; + int refc = 1; /* The mtime of the BFD at the point the cache entry was made. */ time_t mtime; + /* The file size (in bytes) at the point the cache entry was made. */ + off_t size; + + /* The inode of the file at the point the cache entry was made. */ + ino_t inode; + + /* The device id of the file at the point the cache entry was made. */ + dev_t device_id; + /* This is true if we have determined whether this BFD has any sections requiring relocation. */ unsigned int relocation_computed : 1; @@ -80,17 +111,17 @@ struct gdb_bfd_data unsigned int crc_computed : 1; /* The file's CRC. */ - unsigned long crc; + unsigned long crc = 0; /* If the BFD comes from an archive, this points to the archive's BFD. Otherwise, this is NULL. */ - bfd *archive_bfd; + bfd *archive_bfd = nullptr; /* Table of all the bfds this bfd has included. */ - VEC (bfdp) *included_bfds; + std::vector included_bfds; /* The registry. */ - REGISTRY_FIELDS; + REGISTRY_FIELDS = {}; }; #define GDB_BFD_DATA_ACCESSOR(ABFD) \ @@ -102,6 +133,27 @@ DEFINE_REGISTRY (bfd, GDB_BFD_DATA_ACCESSOR) static htab_t gdb_bfd_cache; +/* When true gdb will reuse an existing bfd object if the filename, + modification time, and file size all match. */ + +static bool bfd_sharing = true; +static void +show_bfd_sharing (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("BFD sharing is %s.\n"), value); +} + +/* When non-zero debugging of the bfd caches is enabled. */ + +static unsigned int debug_bfd_cache; +static void +show_bfd_cache_debug (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("BFD cache debugging is %s.\n"), value); +} + /* The type of an object being looked up in gdb_bfd_cache. We use htab's capability of storing one kind of object (BFD in this case) and using a different sort of object for searching. */ @@ -112,6 +164,12 @@ struct gdb_bfd_cache_search const char *filename; /* The mtime. */ time_t mtime; + /* The file size (in bytes). */ + off_t size; + /* The inode of the file. */ + ino_t inode; + /* The device id of the file. */ + dev_t device_id; }; /* A hash function for BFDs. */ @@ -119,7 +177,7 @@ struct gdb_bfd_cache_search static hashval_t hash_bfd (const void *b) { - const bfd *abfd = b; + const bfd *abfd = (const struct bfd *) b; /* It is simplest to just hash the filename. */ return htab_hash_string (bfd_get_filename (abfd)); @@ -131,17 +189,196 @@ hash_bfd (const void *b) static int eq_bfd (const void *a, const void *b) { - const bfd *abfd = a; - const struct gdb_bfd_cache_search *s = b; - struct gdb_bfd_data *gdata = bfd_usrdata (abfd); + const bfd *abfd = (const struct bfd *) a; + const struct gdb_bfd_cache_search *s + = (const struct gdb_bfd_cache_search *) b; + struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd); return (gdata->mtime == s->mtime + && gdata->size == s->size + && gdata->inode == s->inode + && gdata->device_id == s->device_id && strcmp (bfd_get_filename (abfd), s->filename) == 0); } /* See gdb_bfd.h. */ -struct bfd * +int +is_target_filename (const char *name) +{ + return startswith (name, TARGET_SYSROOT_PREFIX); +} + +/* See gdb_bfd.h. */ + +int +gdb_bfd_has_target_filename (struct bfd *abfd) +{ + return is_target_filename (bfd_get_filename (abfd)); +} + + +/* Return the system error number corresponding to ERRNUM. */ + +static int +fileio_errno_to_host (int errnum) +{ + switch (errnum) + { + case FILEIO_EPERM: + return EPERM; + case FILEIO_ENOENT: + return ENOENT; + case FILEIO_EINTR: + return EINTR; + case FILEIO_EIO: + return EIO; + case FILEIO_EBADF: + return EBADF; + case FILEIO_EACCES: + return EACCES; + case FILEIO_EFAULT: + return EFAULT; + case FILEIO_EBUSY: + return EBUSY; + case FILEIO_EEXIST: + return EEXIST; + case FILEIO_ENODEV: + return ENODEV; + case FILEIO_ENOTDIR: + return ENOTDIR; + case FILEIO_EISDIR: + return EISDIR; + case FILEIO_EINVAL: + return EINVAL; + case FILEIO_ENFILE: + return ENFILE; + case FILEIO_EMFILE: + return EMFILE; + case FILEIO_EFBIG: + return EFBIG; + case FILEIO_ENOSPC: + return ENOSPC; + case FILEIO_ESPIPE: + return ESPIPE; + case FILEIO_EROFS: + return EROFS; + case FILEIO_ENOSYS: + return ENOSYS; + case FILEIO_ENAMETOOLONG: + return ENAMETOOLONG; + } + return -1; +} + +/* Wrapper for target_fileio_open suitable for passing as the + OPEN_FUNC argument to gdb_bfd_openr_iovec. The supplied + OPEN_CLOSURE is unused. */ + +static void * +gdb_bfd_iovec_fileio_open (struct bfd *abfd, void *inferior) +{ + const char *filename = bfd_get_filename (abfd); + int fd, target_errno; + int *stream; + + gdb_assert (is_target_filename (filename)); + + fd = target_fileio_open_warn_if_slow ((struct inferior *) inferior, + filename + + strlen (TARGET_SYSROOT_PREFIX), + FILEIO_O_RDONLY, 0, + &target_errno); + if (fd == -1) + { + errno = fileio_errno_to_host (target_errno); + bfd_set_error (bfd_error_system_call); + return NULL; + } + + stream = XCNEW (int); + *stream = fd; + return stream; +} + +/* Wrapper for target_fileio_pread suitable for passing as the + PREAD_FUNC argument to gdb_bfd_openr_iovec. */ + +static file_ptr +gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf, + file_ptr nbytes, file_ptr offset) +{ + int fd = *(int *) stream; + int target_errno; + file_ptr pos, bytes; + + pos = 0; + while (nbytes > pos) + { + QUIT; + + bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos, + nbytes - pos, offset + pos, + &target_errno); + if (bytes == 0) + /* Success, but no bytes, means end-of-file. */ + break; + if (bytes == -1) + { + errno = fileio_errno_to_host (target_errno); + bfd_set_error (bfd_error_system_call); + return -1; + } + + pos += bytes; + } + + return pos; +} + +/* Wrapper for target_fileio_close suitable for passing as the + CLOSE_FUNC argument to gdb_bfd_openr_iovec. */ + +static int +gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream) +{ + int fd = *(int *) stream; + int target_errno; + + xfree (stream); + + /* Ignore errors on close. These may happen with remote + targets if the connection has already been torn down. */ + target_fileio_close (fd, &target_errno); + + /* Zero means success. */ + return 0; +} + +/* Wrapper for target_fileio_fstat suitable for passing as the + STAT_FUNC argument to gdb_bfd_openr_iovec. */ + +static int +gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream, + struct stat *sb) +{ + int fd = *(int *) stream; + int target_errno; + int result; + + result = target_fileio_fstat (fd, sb, &target_errno); + if (result == -1) + { + errno = fileio_errno_to_host (target_errno); + bfd_set_error (bfd_error_system_call); + } + + return result; +} + +/* See gdb_bfd.h. */ + +gdb_bfd_ref_ptr gdb_bfd_open (const char *name, const char *target, int fd) { hashval_t hash; @@ -150,6 +387,23 @@ gdb_bfd_open (const char *name, const char *target, int fd) struct gdb_bfd_cache_search search; struct stat st; + if (is_target_filename (name)) + { + if (!target_filesystem_is_local ()) + { + gdb_assert (fd == -1); + + return gdb_bfd_openr_iovec (name, target, + gdb_bfd_iovec_fileio_open, + current_inferior (), + gdb_bfd_iovec_fileio_pread, + gdb_bfd_iovec_fileio_close, + gdb_bfd_iovec_fileio_fstat); + } + + name += strlen (TARGET_SYSROOT_PREFIX); + } + if (gdb_bfd_cache == NULL) gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL, xcalloc, xfree); @@ -169,33 +423,53 @@ gdb_bfd_open (const char *name, const char *target, int fd) { /* Weird situation here. */ search.mtime = 0; + search.size = 0; + search.inode = 0; + search.device_id = 0; } else - search.mtime = st.st_mtime; + { + search.mtime = st.st_mtime; + search.size = st.st_size; + search.inode = st.st_ino; + search.device_id = st.st_dev; + } /* Note that this must compute the same result as hash_bfd. */ hash = htab_hash_string (name); /* Note that we cannot use htab_find_slot_with_hash here, because opening the BFD may fail; and this would violate hashtab invariants. */ - abfd = htab_find_with_hash (gdb_bfd_cache, &search, hash); - if (abfd != NULL) + abfd = (struct bfd *) htab_find_with_hash (gdb_bfd_cache, &search, hash); + if (bfd_sharing && abfd != NULL) { + if (debug_bfd_cache) + fprintf_unfiltered (gdb_stdlog, + "Reusing cached bfd %s for %s\n", + host_address_to_string (abfd), + bfd_get_filename (abfd)); close (fd); - gdb_bfd_ref (abfd); - return abfd; + return gdb_bfd_ref_ptr::new_reference (abfd); } abfd = bfd_fopen (name, target, FOPEN_RB, fd); if (abfd == NULL) return NULL; - slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT); - gdb_assert (!*slot); - *slot = abfd; + if (debug_bfd_cache) + fprintf_unfiltered (gdb_stdlog, + "Creating new bfd %s for %s\n", + host_address_to_string (abfd), + bfd_get_filename (abfd)); + + if (bfd_sharing) + { + slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT); + gdb_assert (!*slot); + *slot = abfd; + } - gdb_bfd_ref (abfd); - return abfd; + return gdb_bfd_ref_ptr::new_reference (abfd); } /* A helper function that releases any section data attached to the @@ -204,7 +478,8 @@ gdb_bfd_open (const char *name, const char *target, int fd) static void free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore) { - struct gdb_bfd_section_data *sect = bfd_get_section_userdata (abfd, sectp); + struct gdb_bfd_section_data *sect + = (struct gdb_bfd_section_data *) bfd_section_userdata (sectp); if (sect != NULL && sect->data != NULL) { @@ -228,7 +503,7 @@ static int gdb_bfd_close_or_warn (struct bfd *abfd) { int ret; - char *name = bfd_get_filename (abfd); + const char *name = bfd_get_filename (abfd); bfd_map_over_sections (abfd, free_one_bfd_section, NULL); @@ -252,7 +527,13 @@ gdb_bfd_ref (struct bfd *abfd) if (abfd == NULL) return; - gdata = bfd_usrdata (abfd); + gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd); + + if (debug_bfd_cache) + fprintf_unfiltered (gdb_stdlog, + "Increase reference count on bfd %s (%s)\n", + host_address_to_string (abfd), + bfd_get_filename (abfd)); if (gdata != NULL) { @@ -263,12 +544,8 @@ gdb_bfd_ref (struct bfd *abfd) /* Ask BFD to decompress sections in bfd_get_full_section_contents. */ abfd->flags |= BFD_DECOMPRESS; - gdata = bfd_zalloc (abfd, sizeof (struct gdb_bfd_data)); - gdata->refc = 1; - gdata->mtime = bfd_get_mtime (abfd); - gdata->archive_bfd = NULL; - bfd_usrdata (abfd) = gdata; - + gdata = new gdb_bfd_data (abfd); + bfd_set_usrdata (abfd, gdata); bfd_alloc_data (abfd); /* This is the first we've seen it, so add it to the hash table. */ @@ -282,20 +559,32 @@ gdb_bfd_ref (struct bfd *abfd) void gdb_bfd_unref (struct bfd *abfd) { - int ix; struct gdb_bfd_data *gdata; struct gdb_bfd_cache_search search; - bfd *archive_bfd, *included_bfd; + bfd *archive_bfd; if (abfd == NULL) return; - gdata = bfd_usrdata (abfd); + gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd); gdb_assert (gdata->refc >= 1); gdata->refc -= 1; if (gdata->refc > 0) - return; + { + if (debug_bfd_cache) + fprintf_unfiltered (gdb_stdlog, + "Decrease reference count on bfd %s (%s)\n", + host_address_to_string (abfd), + bfd_get_filename (abfd)); + return; + } + + if (debug_bfd_cache) + fprintf_unfiltered (gdb_stdlog, + "Delete final reference count on bfd %s (%s)\n", + host_address_to_string (abfd), + bfd_get_filename (abfd)); archive_bfd = gdata->archive_bfd; search.filename = bfd_get_filename (abfd); @@ -306,6 +595,9 @@ gdb_bfd_unref (struct bfd *abfd) void **slot; search.mtime = gdata->mtime; + search.size = gdata->size; + search.inode = gdata->inode; + search.device_id = gdata->device_id; slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, NO_INSERT); @@ -313,14 +605,9 @@ gdb_bfd_unref (struct bfd *abfd) htab_clear_slot (gdb_bfd_cache, slot); } - for (ix = 0; - VEC_iterate (bfdp, gdata->included_bfds, ix, included_bfd); - ++ix) - gdb_bfd_unref (included_bfd); - VEC_free (bfdp, gdata->included_bfds); - bfd_free_data (abfd); - bfd_usrdata (abfd) = NULL; /* Paranoia. */ + delete gdata; + bfd_set_usrdata (abfd, NULL); /* Paranoia. */ htab_remove_elt (all_bfds, abfd); @@ -338,12 +625,13 @@ get_section_descriptor (asection *section) { struct gdb_bfd_section_data *result; - result = bfd_get_section_userdata (section->owner, section); + result = (struct gdb_bfd_section_data *) bfd_section_userdata (section); if (result == NULL) { - result = bfd_zalloc (section->owner, sizeof (*result)); - bfd_set_section_userdata (section->owner, section, result); + result = ((struct gdb_bfd_section_data *) + bfd_zalloc (section->owner, sizeof (*result))); + bfd_set_section_userdata (section, result); } return result; @@ -381,9 +669,9 @@ gdb_bfd_map_section (asection *sectp, bfd_size_type *size) /* Only try to mmap sections which are large enough: we don't want to waste space due to fragmentation. */ - if (bfd_get_section_size (sectp) > 4 * pagesize) + if (bfd_section_size (sectp) > 4 * pagesize) { - descriptor->size = bfd_get_section_size (sectp); + descriptor->size = bfd_section_size (sectp); descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ, MAP_PRIVATE, sectp->filepos, &descriptor->map_addr, @@ -407,20 +695,26 @@ gdb_bfd_map_section (asection *sectp, bfd_size_type *size) /* Handle compressed sections, or ordinary uncompressed sections in the no-mmap case. */ - descriptor->size = bfd_get_section_size (sectp); + descriptor->size = bfd_section_size (sectp); descriptor->data = NULL; data = NULL; if (!bfd_get_full_section_contents (abfd, sectp, &data)) - error (_("Can't read data for section '%s' in file '%s'"), - bfd_get_section_name (abfd, sectp), - bfd_get_filename (abfd)); + { + warning (_("Can't read data for section '%s' in file '%s'"), + bfd_section_name (sectp), + bfd_get_filename (abfd)); + /* Set size to 0 to prevent further attempts to read the invalid + section. */ + *size = 0; + return NULL; + } descriptor->data = data; done: gdb_assert (descriptor->data != NULL); *size = descriptor->size; - return descriptor->data; + return (const gdb_byte *) descriptor->data; } /* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and @@ -465,7 +759,7 @@ get_file_crc (bfd *abfd, unsigned long *file_crc_return) int gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out) { - struct gdb_bfd_data *gdata = bfd_usrdata (abfd); + struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd); if (!gdata->crc_computed) gdata->crc_computed = get_file_crc (abfd, &gdata->crc); @@ -479,47 +773,38 @@ gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out) /* See gdb_bfd.h. */ -bfd * +gdb_bfd_ref_ptr gdb_bfd_fopen (const char *filename, const char *target, const char *mode, int fd) { bfd *result = bfd_fopen (filename, target, mode, fd); - if (result) - gdb_bfd_ref (result); - - return result; + return gdb_bfd_ref_ptr::new_reference (result); } /* See gdb_bfd.h. */ -bfd * +gdb_bfd_ref_ptr gdb_bfd_openr (const char *filename, const char *target) { bfd *result = bfd_openr (filename, target); - if (result) - gdb_bfd_ref (result); - - return result; + return gdb_bfd_ref_ptr::new_reference (result); } /* See gdb_bfd.h. */ -bfd * +gdb_bfd_ref_ptr gdb_bfd_openw (const char *filename, const char *target) { bfd *result = bfd_openw (filename, target); - if (result) - gdb_bfd_ref (result); - - return result; + return gdb_bfd_ref_ptr::new_reference (result); } /* See gdb_bfd.h. */ -bfd * +gdb_bfd_ref_ptr gdb_bfd_openr_iovec (const char *filename, const char *target, void *(*open_func) (struct bfd *nbfd, void *open_closure), @@ -539,10 +824,7 @@ gdb_bfd_openr_iovec (const char *filename, const char *target, open_func, open_closure, pread_func, close_func, stat_func); - if (result) - gdb_bfd_ref (result); - - return result; + return gdb_bfd_ref_ptr::new_reference (result); } /* See gdb_bfd.h. */ @@ -556,7 +838,7 @@ gdb_bfd_mark_parent (bfd *child, bfd *parent) /* No need to stash the filename here, because we also keep a reference on the parent archive. */ - gdata = bfd_usrdata (child); + gdata = (struct gdb_bfd_data *) bfd_usrdata (child); if (gdata->archive_bfd == NULL) { gdata->archive_bfd = parent; @@ -568,7 +850,7 @@ gdb_bfd_mark_parent (bfd *child, bfd *parent) /* See gdb_bfd.h. */ -bfd * +gdb_bfd_ref_ptr gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous) { bfd *result = bfd_openr_next_archived_file (archive, previous); @@ -576,7 +858,7 @@ gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous) if (result) gdb_bfd_mark_parent (result, archive); - return result; + return gdb_bfd_ref_ptr (result); } /* See gdb_bfd.h. */ @@ -586,22 +868,8 @@ gdb_bfd_record_inclusion (bfd *includer, bfd *includee) { struct gdb_bfd_data *gdata; - gdb_bfd_ref (includee); - gdata = bfd_usrdata (includer); - VEC_safe_push (bfdp, gdata->included_bfds, includee); -} - -/* See gdb_bfd.h. */ - -bfd * -gdb_bfd_fdopenr (const char *filename, const char *target, int fd) -{ - bfd *result = bfd_fdopenr (filename, target, fd); - - if (result) - gdb_bfd_ref (result); - - return result; + gdata = (struct gdb_bfd_data *) bfd_usrdata (includer); + gdata->included_bfds.push_back (gdb_bfd_ref_ptr::new_reference (includee)); } @@ -616,13 +884,13 @@ gdb_bfd_section_index (bfd *abfd, asection *section) if (section == NULL) return -1; else if (section == bfd_com_section_ptr) - return bfd_count_sections (abfd) + 1; + return bfd_count_sections (abfd); else if (section == bfd_und_section_ptr) - return bfd_count_sections (abfd) + 2; + return bfd_count_sections (abfd) + 1; else if (section == bfd_abs_section_ptr) - return bfd_count_sections (abfd) + 3; + return bfd_count_sections (abfd) + 2; else if (section == bfd_ind_section_ptr) - return bfd_count_sections (abfd) + 4; + return bfd_count_sections (abfd) + 3; return section->index; } @@ -639,7 +907,7 @@ gdb_bfd_count_sections (bfd *abfd) int gdb_bfd_requires_relocations (bfd *abfd) { - struct gdb_bfd_data *gdata = bfd_usrdata (abfd); + struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd); if (gdata->relocation_computed == 0) { @@ -665,17 +933,15 @@ gdb_bfd_requires_relocations (bfd *abfd) static int print_one_bfd (void **slot, void *data) { - bfd *abfd = *slot; - struct gdb_bfd_data *gdata = bfd_usrdata (abfd); - struct ui_out *uiout = data; - struct cleanup *inner; + bfd *abfd = (struct bfd *) *slot; + struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd); + struct ui_out *uiout = (struct ui_out *) data; - inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_int (uiout, "refcount", gdata->refc); - ui_out_field_string (uiout, "addr", host_address_to_string (abfd)); - ui_out_field_string (uiout, "filename", bfd_get_filename (abfd)); - ui_out_text (uiout, "\n"); - do_cleanups (inner); + ui_out_emit_tuple tuple_emitter (uiout, NULL); + uiout->field_signed ("refcount", gdata->refc); + uiout->field_string ("addr", host_address_to_string (abfd)); + uiout->field_string ("filename", bfd_get_filename (abfd)); + uiout->text ("\n"); return 1; } @@ -683,25 +949,19 @@ print_one_bfd (void **slot, void *data) /* Implement the 'maint info bfd' command. */ static void -maintenance_info_bfds (char *arg, int from_tty) +maintenance_info_bfds (const char *arg, int from_tty) { - struct cleanup *cleanup; struct ui_out *uiout = current_uiout; - cleanup = make_cleanup_ui_out_table_begin_end (uiout, 3, -1, "bfds"); - ui_out_table_header (uiout, 10, ui_left, "refcount", "Refcount"); - ui_out_table_header (uiout, 18, ui_left, "addr", "Address"); - ui_out_table_header (uiout, 40, ui_left, "filename", "Filename"); + ui_out_emit_table table_emitter (uiout, 3, -1, "bfds"); + uiout->table_header (10, ui_left, "refcount", "Refcount"); + uiout->table_header (18, ui_left, "addr", "Address"); + uiout->table_header (40, ui_left, "filename", "Filename"); - ui_out_table_body (uiout); + uiout->table_body (); htab_traverse (all_bfds, print_one_bfd, uiout); - - do_cleanups (cleanup); } -/* -Wmissing-prototypes */ -extern initialize_file_ftype _initialize_gdb_bfd; - void _initialize_gdb_bfd (void) { @@ -711,4 +971,25 @@ _initialize_gdb_bfd (void) add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\ List the BFDs that are currently open."), &maintenanceinfolist); + + add_setshow_boolean_cmd ("bfd-sharing", no_class, + &bfd_sharing, _("\ +Set whether gdb will share bfds that appear to be the same file."), _("\ +Show whether gdb will share bfds that appear to be the same file."), _("\ +When enabled gdb will reuse existing bfds rather than reopening the\n\ +same file. To decide if two files are the same then gdb compares the\n\ +filename, file size, file modification time, and file inode."), + NULL, + &show_bfd_sharing, + &maintenance_set_cmdlist, + &maintenance_show_cmdlist); + + add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance, + &debug_bfd_cache, _("\ +Set bfd cache debugging."), _("\ +Show bfd cache debugging."), _("\ +When non-zero, bfd cache specific debugging is enabled."), + NULL, + &show_bfd_cache_debug, + &setdebuglist, &showdebuglist); }