X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdb_bfd.c;h=df00f87c8a7555eea4af5d8fb76dd28694927b0c;hb=c5ac15402a894e87a118526a066880f596b3c78d;hp=25cee5c630ce7d79073b28443c4155b070b100a5;hpb=1da77581c0559e62b80b27f06f81dad4c7a7a0be;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdb_bfd.c b/gdb/gdb_bfd.c index 25cee5c630..df00f87c8a 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-2013 Free Software Foundation, Inc. + Copyright (C) 2011-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -19,21 +19,23 @@ #include "defs.h" #include "gdb_bfd.h" -#include "gdb_assert.h" -#include "gdb_string.h" #include "ui-out.h" #include "gdbcmd.h" #include "hashtab.h" #include "filestuff.h" -#ifdef HAVE_ZLIB_H -#include -#endif +#include "vec.h" #ifdef HAVE_MMAP #include #ifndef MAP_FAILED #define MAP_FAILED ((void *) -1) #endif #endif +#include "target.h" +#include "gdb/fileio.h" +#include "inferior.h" + +typedef bfd *bfdp; +DEF_VEC_P (bfdp); /* An object of this type is stored in the section's user data when mapping a section. */ @@ -57,21 +59,6 @@ struct gdb_bfd_section_data static htab_t all_bfds; -/* See gdb_bfd.h. */ - -void -gdb_bfd_stash_filename (struct bfd *abfd) -{ - char *name = bfd_get_filename (abfd); - char *data; - - data = bfd_alloc (abfd, strlen (name) + 1); - strcpy (data, name); - - /* Unwarranted chumminess with BFD. */ - abfd->filename = data; -} - /* An object of this type is stored in each BFD's user data. */ struct gdb_bfd_data @@ -82,6 +69,15 @@ struct gdb_bfd_data /* 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; @@ -99,6 +95,9 @@ struct gdb_bfd_data BFD. Otherwise, this is NULL. */ bfd *archive_bfd; + /* Table of all the bfds this bfd has included. */ + VEC (bfdp) *included_bfds; + /* The registry. */ REGISTRY_FIELDS; }; @@ -112,6 +111,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 int bfd_sharing = 1; +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. */ @@ -122,6 +142,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. */ @@ -129,7 +155,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)); @@ -141,16 +167,195 @@ 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. */ +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. */ + struct bfd * gdb_bfd_open (const char *name, const char *target, int fd) { @@ -160,6 +365,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); @@ -179,18 +401,31 @@ 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; @@ -200,11 +435,19 @@ gdb_bfd_open (const char *name, const char *target, int 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_stash_filename (abfd); gdb_bfd_ref (abfd); return abfd; } @@ -215,7 +458,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_get_section_userdata (abfd, sectp); if (sect != NULL && sect->data != NULL) { @@ -257,13 +501,20 @@ gdb_bfd_close_or_warn (struct bfd *abfd) void gdb_bfd_ref (struct bfd *abfd) { + struct stat buf; struct gdb_bfd_data *gdata; void **slot; 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) { @@ -274,10 +525,23 @@ 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 + = (struct gdb_bfd_data *) bfd_zalloc (abfd, sizeof (struct gdb_bfd_data)); gdata->refc = 1; gdata->mtime = bfd_get_mtime (abfd); + gdata->size = bfd_get_size (abfd); gdata->archive_bfd = NULL; + if (bfd_stat (abfd, &buf) == 0) + { + gdata->inode = buf.st_ino; + gdata->device_id = buf.st_dev; + } + else + { + /* The stat failed. */ + gdata->inode = 0; + gdata->device_id = 0; + } bfd_usrdata (abfd) = gdata; bfd_alloc_data (abfd); @@ -293,19 +557,33 @@ 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; + bfd *archive_bfd, *included_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); @@ -316,6 +594,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); @@ -323,6 +604,12 @@ 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. */ @@ -342,11 +629,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_get_section_userdata (section->owner, section)); if (result == NULL) { - result = bfd_zalloc (section->owner, sizeof (*result)); + result = ((struct gdb_bfd_section_data *) + bfd_zalloc (section->owner, sizeof (*result))); bfd_set_section_userdata (section->owner, section, result); } @@ -424,7 +713,7 @@ gdb_bfd_map_section (asection *sectp, bfd_size_type *size) 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 @@ -469,7 +758,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); @@ -490,10 +779,7 @@ gdb_bfd_fopen (const char *filename, const char *target, const char *mode, bfd *result = bfd_fopen (filename, target, mode, fd); if (result) - { - gdb_bfd_stash_filename (result); - gdb_bfd_ref (result); - } + gdb_bfd_ref (result); return result; } @@ -506,10 +792,7 @@ gdb_bfd_openr (const char *filename, const char *target) bfd *result = bfd_openr (filename, target); if (result) - { - gdb_bfd_stash_filename (result); - gdb_bfd_ref (result); - } + gdb_bfd_ref (result); return result; } @@ -522,10 +805,7 @@ gdb_bfd_openw (const char *filename, const char *target) bfd *result = bfd_openw (filename, target); if (result) - { - gdb_bfd_stash_filename (result); - gdb_bfd_ref (result); - } + gdb_bfd_ref (result); return result; } @@ -553,10 +833,7 @@ gdb_bfd_openr_iovec (const char *filename, const char *target, pread_func, close_func, stat_func); if (result) - { - gdb_bfd_ref (result); - gdb_bfd_stash_filename (result); - } + gdb_bfd_ref (result); return result; } @@ -572,7 +849,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; @@ -597,16 +874,25 @@ gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous) /* See gdb_bfd.h. */ +void +gdb_bfd_record_inclusion (bfd *includer, bfd *includee) +{ + struct gdb_bfd_data *gdata; + + gdb_bfd_ref (includee); + gdata = (struct gdb_bfd_data *) 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); - gdb_bfd_stash_filename (result); - } + gdb_bfd_ref (result); return result; } @@ -623,13 +909,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; } @@ -646,7 +932,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) { @@ -672,9 +958,9 @@ 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; + 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; struct cleanup *inner; inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); @@ -718,4 +1004,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); }