gdb/gdb_bfd.c

   1 /* Definitions for BFD wrappers used by GDB.
   2
   3    Copyright (C) 2011-2015 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 #include "defs.h"
  21 #include "gdb_bfd.h"
  22 #include "ui-out.h"
  23 #include "gdbcmd.h"
  24 #include "hashtab.h"
  25 #include "filestuff.h"
  26 #include "vec.h"
  27 #ifdef HAVE_MMAP
  28 #include <sys/mman.h>
  29 #ifndef MAP_FAILED
  30 #define MAP_FAILED ((void *) -1)
  31 #endif
  32 #endif
  33 #include "target.h"
  34 #include "gdb/fileio.h"
  35 #include "inferior.h"
  36
  37 typedef bfd *bfdp;
  38 DEF_VEC_P (bfdp);
  39
  40 /* An object of this type is stored in the section's user data when
  41    mapping a section.  */
  42
  43 struct gdb_bfd_section_data
  44 {
  45   /* Size of the data.  */
  46   bfd_size_type size;
  47   /* If the data was mmapped, this is the length of the map.  */
  48   bfd_size_type map_len;
  49   /* The data.  If NULL, the section data has not been read.  */
  50   void *data;
  51   /* If the data was mmapped, this is the map address.  */
  52   void *map_addr;
  53 };
  54
  55 /* A hash table holding every BFD that gdb knows about.  This is not
  56    to be confused with 'gdb_bfd_cache', which is used for sharing
  57    BFDs; in contrast, this hash is used just to implement
  58    "maint info bfd".  */
  59
  60 static htab_t all_bfds;
  61
  62 /* An object of this type is stored in each BFD's user data.  */
  63
  64 struct gdb_bfd_data
  65 {
  66   /* The reference count.  */
  67   int refc;
  68
  69   /* The mtime of the BFD at the point the cache entry was made.  */
  70   time_t mtime;
  71
  72   /* The file size (in bytes) at the point the cache entry was made.  */
  73   off_t size;
  74
  75   /* The inode of the file at the point the cache entry was made.  */
  76   ino_t inode;
  77
  78   /* The device id of the file at the point the cache entry was made.  */
  79   dev_t device_id;
  80
  81   /* This is true if we have determined whether this BFD has any
  82      sections requiring relocation.  */
  83   unsigned int relocation_computed : 1;
  84
  85   /* This is true if any section needs relocation.  */
  86   unsigned int needs_relocations : 1;
  87
  88   /* This is true if we have successfully computed the file's CRC.  */
  89   unsigned int crc_computed : 1;
  90
  91   /* The file's CRC.  */
  92   unsigned long crc;
  93
  94   /* If the BFD comes from an archive, this points to the archive's
  95      BFD.  Otherwise, this is NULL.  */
  96   bfd *archive_bfd;
  97
  98   /* Table of all the bfds this bfd has included.  */
  99   VEC (bfdp) *included_bfds;
 100
 101   /* The registry.  */
 102   REGISTRY_FIELDS;
 103 };
 104
 105 #define GDB_BFD_DATA_ACCESSOR(ABFD) \
 106   ((struct gdb_bfd_data *) bfd_usrdata (ABFD))
 107
 108 DEFINE_REGISTRY (bfd, GDB_BFD_DATA_ACCESSOR)
 109
 110 /* A hash table storing all the BFDs maintained in the cache.  */
 111
 112 static htab_t gdb_bfd_cache;
 113
 114 /* When true gdb will reuse an existing bfd object if the filename,
 115    modification time, and file size all match.  */
 116
 117 static int bfd_sharing = 1;
 118 static void
 119 show_bfd_sharing  (struct ui_file *file, int from_tty,
 120                    struct cmd_list_element *c, const char *value)
 121 {
 122   fprintf_filtered (file, _("BFD sharing is %s.\n"), value);
 123 }
 124
 125 /* When non-zero debugging of the bfd caches is enabled.  */
 126
 127 static unsigned int debug_bfd_cache;
 128 static void
 129 show_bfd_cache_debug (struct ui_file *file, int from_tty,
 130                       struct cmd_list_element *c, const char *value)
 131 {
 132   fprintf_filtered (file, _("BFD cache debugging is %s.\n"), value);
 133 }
 134
 135 /* The type of an object being looked up in gdb_bfd_cache.  We use
 136    htab's capability of storing one kind of object (BFD in this case)
 137    and using a different sort of object for searching.  */
 138
 139 struct gdb_bfd_cache_search
 140 {
 141   /* The filename.  */
 142   const char *filename;
 143   /* The mtime.  */
 144   time_t mtime;
 145   /* The file size (in bytes).  */
 146   off_t size;
 147   /* The inode of the file.  */
 148   ino_t inode;
 149   /* The device id of the file.  */
 150   dev_t device_id;
 151 };
 152
 153 /* A hash function for BFDs.  */
 154
 155 static hashval_t
 156 hash_bfd (const void *b)
 157 {
 158   const bfd *abfd = b;
 159
 160   /* It is simplest to just hash the filename.  */
 161   return htab_hash_string (bfd_get_filename (abfd));
 162 }
 163
 164 /* An equality function for BFDs.  Note that this expects the caller
 165    to search using struct gdb_bfd_cache_search only, not BFDs.  */
 166
 167 static int
 168 eq_bfd (const void *a, const void *b)
 169 {
 170   const bfd *abfd = a;
 171   const struct gdb_bfd_cache_search *s = b;
 172   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 173
 174   return (gdata->mtime == s->mtime
 175           && gdata->size == s->size
 176           && gdata->inode == s->inode
 177           && gdata->device_id == s->device_id
 178           && strcmp (bfd_get_filename (abfd), s->filename) == 0);
 179 }
 180
 181 /* See gdb_bfd.h.  */
 182
 183 int
 184 is_target_filename (const char *name)
 185 {
 186   return startswith (name, TARGET_SYSROOT_PREFIX);
 187 }
 188
 189 /* See gdb_bfd.h.  */
 190
 191 int
 192 gdb_bfd_has_target_filename (struct bfd *abfd)
 193 {
 194   return is_target_filename (bfd_get_filename (abfd));
 195 }
 196
 197
 198 /* Return the system error number corresponding to ERRNUM.  */
 199
 200 static int
 201 fileio_errno_to_host (int errnum)
 202 {
 203   switch (errnum)
 204     {
 205       case FILEIO_EPERM:
 206         return EPERM;
 207       case FILEIO_ENOENT:
 208         return ENOENT;
 209       case FILEIO_EINTR:
 210         return EINTR;
 211       case FILEIO_EIO:
 212         return EIO;
 213       case FILEIO_EBADF:
 214         return EBADF;
 215       case FILEIO_EACCES:
 216         return EACCES;
 217       case FILEIO_EFAULT:
 218         return EFAULT;
 219       case FILEIO_EBUSY:
 220         return EBUSY;
 221       case FILEIO_EEXIST:
 222         return EEXIST;
 223       case FILEIO_ENODEV:
 224         return ENODEV;
 225       case FILEIO_ENOTDIR:
 226         return ENOTDIR;
 227       case FILEIO_EISDIR:
 228         return EISDIR;
 229       case FILEIO_EINVAL:
 230         return EINVAL;
 231       case FILEIO_ENFILE:
 232         return ENFILE;
 233       case FILEIO_EMFILE:
 234         return EMFILE;
 235       case FILEIO_EFBIG:
 236         return EFBIG;
 237       case FILEIO_ENOSPC:
 238         return ENOSPC;
 239       case FILEIO_ESPIPE:
 240         return ESPIPE;
 241       case FILEIO_EROFS:
 242         return EROFS;
 243       case FILEIO_ENOSYS:
 244         return ENOSYS;
 245       case FILEIO_ENAMETOOLONG:
 246         return ENAMETOOLONG;
 247     }
 248   return -1;
 249 }
 250
 251 /* Wrapper for target_fileio_open suitable for passing as the
 252    OPEN_FUNC argument to gdb_bfd_openr_iovec.  The supplied
 253    OPEN_CLOSURE is unused.  */
 254
 255 static void *
 256 gdb_bfd_iovec_fileio_open (struct bfd *abfd, void *inferior)
 257 {
 258   const char *filename = bfd_get_filename (abfd);
 259   int fd, target_errno;
 260   int *stream;
 261
 262   gdb_assert (is_target_filename (filename));
 263
 264   fd = target_fileio_open_warn_if_slow ((struct inferior *) inferior,
 265                                         filename
 266                                         + strlen (TARGET_SYSROOT_PREFIX),
 267                                         FILEIO_O_RDONLY, 0,
 268                                         &target_errno);
 269   if (fd == -1)
 270     {
 271       errno = fileio_errno_to_host (target_errno);
 272       bfd_set_error (bfd_error_system_call);
 273       return NULL;
 274     }
 275
 276   stream = XCNEW (int);
 277   *stream = fd;
 278   return stream;
 279 }
 280
 281 /* Wrapper for target_fileio_pread suitable for passing as the
 282    PREAD_FUNC argument to gdb_bfd_openr_iovec.  */
 283
 284 static file_ptr
 285 gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf,
 286                             file_ptr nbytes, file_ptr offset)
 287 {
 288   int fd = *(int *) stream;
 289   int target_errno;
 290   file_ptr pos, bytes;
 291
 292   pos = 0;
 293   while (nbytes > pos)
 294     {
 295       QUIT;
 296
 297       bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos,
 298                                    nbytes - pos, offset + pos,
 299                                    &target_errno);
 300       if (bytes == 0)
 301         /* Success, but no bytes, means end-of-file.  */
 302         break;
 303       if (bytes == -1)
 304         {
 305           errno = fileio_errno_to_host (target_errno);
 306           bfd_set_error (bfd_error_system_call);
 307           return -1;
 308         }
 309
 310       pos += bytes;
 311     }
 312
 313   return pos;
 314 }
 315
 316 /* Wrapper for target_fileio_close suitable for passing as the
 317    CLOSE_FUNC argument to gdb_bfd_openr_iovec.  */
 318
 319 static int
 320 gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream)
 321 {
 322   int fd = *(int *) stream;
 323   int target_errno;
 324
 325   xfree (stream);
 326
 327   /* Ignore errors on close.  These may happen with remote
 328      targets if the connection has already been torn down.  */
 329   target_fileio_close (fd, &target_errno);
 330
 331   /* Zero means success.  */
 332   return 0;
 333 }
 334
 335 /* Wrapper for target_fileio_fstat suitable for passing as the
 336    STAT_FUNC argument to gdb_bfd_openr_iovec.  */
 337
 338 static int
 339 gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream,
 340                             struct stat *sb)
 341 {
 342   int fd = *(int *) stream;
 343   int target_errno;
 344   int result;
 345
 346   result = target_fileio_fstat (fd, sb, &target_errno);
 347   if (result == -1)
 348     {
 349       errno = fileio_errno_to_host (target_errno);
 350       bfd_set_error (bfd_error_system_call);
 351     }
 352
 353   return result;
 354 }
 355
 356 /* See gdb_bfd.h.  */
 357
 358 struct bfd *
 359 gdb_bfd_open (const char *name, const char *target, int fd)
 360 {
 361   hashval_t hash;
 362   void **slot;
 363   bfd *abfd;
 364   struct gdb_bfd_cache_search search;
 365   struct stat st;
 366
 367   if (is_target_filename (name))
 368     {
 369       if (!target_filesystem_is_local ())
 370         {
 371           gdb_assert (fd == -1);
 372
 373           return gdb_bfd_openr_iovec (name, target,
 374                                       gdb_bfd_iovec_fileio_open,
 375                                       current_inferior (),
 376                                       gdb_bfd_iovec_fileio_pread,
 377                                       gdb_bfd_iovec_fileio_close,
 378                                       gdb_bfd_iovec_fileio_fstat);
 379         }
 380
 381       name += strlen (TARGET_SYSROOT_PREFIX);
 382     }
 383
 384   if (gdb_bfd_cache == NULL)
 385     gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
 386                                        xcalloc, xfree);
 387
 388   if (fd == -1)
 389     {
 390       fd = gdb_open_cloexec (name, O_RDONLY | O_BINARY, 0);
 391       if (fd == -1)
 392         {
 393           bfd_set_error (bfd_error_system_call);
 394           return NULL;
 395         }
 396     }
 397
 398   search.filename = name;
 399   if (fstat (fd, &st) < 0)
 400     {
 401       /* Weird situation here.  */
 402       search.mtime = 0;
 403       search.size = 0;
 404       search.inode = 0;
 405       search.device_id = 0;
 406     }
 407   else
 408     {
 409       search.mtime = st.st_mtime;
 410       search.size = st.st_size;
 411       search.inode = st.st_ino;
 412       search.device_id = st.st_dev;
 413     }
 414
 415   /* Note that this must compute the same result as hash_bfd.  */
 416   hash = htab_hash_string (name);
 417   /* Note that we cannot use htab_find_slot_with_hash here, because
 418      opening the BFD may fail; and this would violate hashtab
 419      invariants.  */
 420   abfd = htab_find_with_hash (gdb_bfd_cache, &search, hash);
 421   if (bfd_sharing && abfd != NULL)
 422     {
 423       if (debug_bfd_cache)
 424         fprintf_unfiltered (gdb_stdlog,
 425                             "Reusing cached bfd %s for %s\n",
 426                             host_address_to_string (abfd),
 427                             bfd_get_filename (abfd));
 428       close (fd);
 429       gdb_bfd_ref (abfd);
 430       return abfd;
 431     }
 432
 433   abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 434   if (abfd == NULL)
 435     return NULL;
 436
 437   if (debug_bfd_cache)
 438     fprintf_unfiltered (gdb_stdlog,
 439                         "Creating new bfd %s for %s\n",
 440                         host_address_to_string (abfd),
 441                         bfd_get_filename (abfd));
 442
 443   if (bfd_sharing)
 444     {
 445       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
 446       gdb_assert (!*slot);
 447       *slot = abfd;
 448     }
 449
 450   gdb_bfd_ref (abfd);
 451   return abfd;
 452 }
 453
 454 /* A helper function that releases any section data attached to the
 455    BFD.  */
 456
 457 static void
 458 free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
 459 {
 460   struct gdb_bfd_section_data *sect = bfd_get_section_userdata (abfd, sectp);
 461
 462   if (sect != NULL && sect->data != NULL)
 463     {
 464 #ifdef HAVE_MMAP
 465       if (sect->map_addr != NULL)
 466         {
 467           int res;
 468
 469           res = munmap (sect->map_addr, sect->map_len);
 470           gdb_assert (res == 0);
 471         }
 472       else
 473 #endif
 474         xfree (sect->data);
 475     }
 476 }
 477
 478 /* Close ABFD, and warn if that fails.  */
 479
 480 static int
 481 gdb_bfd_close_or_warn (struct bfd *abfd)
 482 {
 483   int ret;
 484   char *name = bfd_get_filename (abfd);
 485
 486   bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
 487
 488   ret = bfd_close (abfd);
 489
 490   if (!ret)
 491     warning (_("cannot close \"%s\": %s"),
 492              name, bfd_errmsg (bfd_get_error ()));
 493
 494   return ret;
 495 }
 496
 497 /* See gdb_bfd.h.  */
 498
 499 void
 500 gdb_bfd_ref (struct bfd *abfd)
 501 {
 502   struct stat buf;
 503   struct gdb_bfd_data *gdata;
 504   void **slot;
 505
 506   if (abfd == NULL)
 507     return;
 508
 509   gdata = bfd_usrdata (abfd);
 510
 511   if (debug_bfd_cache)
 512     fprintf_unfiltered (gdb_stdlog,
 513                         "Increase reference count on bfd %s (%s)\n",
 514                         host_address_to_string (abfd),
 515                         bfd_get_filename (abfd));
 516
 517   if (gdata != NULL)
 518     {
 519       gdata->refc += 1;
 520       return;
 521     }
 522
 523   /* Ask BFD to decompress sections in bfd_get_full_section_contents.  */
 524   abfd->flags |= BFD_DECOMPRESS;
 525
 526   gdata = bfd_zalloc (abfd, sizeof (struct gdb_bfd_data));
 527   gdata->refc = 1;
 528   gdata->mtime = bfd_get_mtime (abfd);
 529   gdata->size = bfd_get_size (abfd);
 530   gdata->archive_bfd = NULL;
 531   if (bfd_stat (abfd, &buf) == 0)
 532     {
 533       gdata->inode = buf.st_ino;
 534       gdata->device_id = buf.st_dev;
 535     }
 536   else
 537     {
 538       /* The stat failed.  */
 539       gdata->inode = 0;
 540       gdata->device_id = 0;
 541     }
 542   bfd_usrdata (abfd) = gdata;
 543
 544   bfd_alloc_data (abfd);
 545
 546   /* This is the first we've seen it, so add it to the hash table.  */
 547   slot = htab_find_slot (all_bfds, abfd, INSERT);
 548   gdb_assert (slot && !*slot);
 549   *slot = abfd;
 550 }
 551
 552 /* See gdb_bfd.h.  */
 553
 554 void
 555 gdb_bfd_unref (struct bfd *abfd)
 556 {
 557   int ix;
 558   struct gdb_bfd_data *gdata;
 559   struct gdb_bfd_cache_search search;
 560   bfd *archive_bfd, *included_bfd;
 561
 562   if (abfd == NULL)
 563     return;
 564
 565   gdata = bfd_usrdata (abfd);
 566   gdb_assert (gdata->refc >= 1);
 567
 568   gdata->refc -= 1;
 569   if (gdata->refc > 0)
 570     {
 571       if (debug_bfd_cache)
 572         fprintf_unfiltered (gdb_stdlog,
 573                             "Decrease reference count on bfd %s (%s)\n",
 574                             host_address_to_string (abfd),
 575                             bfd_get_filename (abfd));
 576       return;
 577     }
 578
 579   if (debug_bfd_cache)
 580     fprintf_unfiltered (gdb_stdlog,
 581                         "Delete final reference count on bfd %s (%s)\n",
 582                         host_address_to_string (abfd),
 583                         bfd_get_filename (abfd));
 584
 585   archive_bfd = gdata->archive_bfd;
 586   search.filename = bfd_get_filename (abfd);
 587
 588   if (gdb_bfd_cache && search.filename)
 589     {
 590       hashval_t hash = htab_hash_string (search.filename);
 591       void **slot;
 592
 593       search.mtime = gdata->mtime;
 594       search.size = gdata->size;
 595       search.inode = gdata->inode;
 596       search.device_id = gdata->device_id;
 597       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 598                                        NO_INSERT);
 599
 600       if (slot && *slot)
 601         htab_clear_slot (gdb_bfd_cache, slot);
 602     }
 603
 604   for (ix = 0;
 605        VEC_iterate (bfdp, gdata->included_bfds, ix, included_bfd);
 606        ++ix)
 607     gdb_bfd_unref (included_bfd);
 608   VEC_free (bfdp, gdata->included_bfds);
 609
 610   bfd_free_data (abfd);
 611   bfd_usrdata (abfd) = NULL;  /* Paranoia.  */
 612
 613   htab_remove_elt (all_bfds, abfd);
 614
 615   gdb_bfd_close_or_warn (abfd);
 616
 617   gdb_bfd_unref (archive_bfd);
 618 }
 619
 620 /* A helper function that returns the section data descriptor
 621    associated with SECTION.  If no such descriptor exists, a new one
 622    is allocated and cleared.  */
 623
 624 static struct gdb_bfd_section_data *
 625 get_section_descriptor (asection *section)
 626 {
 627   struct gdb_bfd_section_data *result;
 628
 629   result = bfd_get_section_userdata (section->owner, section);
 630
 631   if (result == NULL)
 632     {
 633       result = bfd_zalloc (section->owner, sizeof (*result));
 634       bfd_set_section_userdata (section->owner, section, result);
 635     }
 636
 637   return result;
 638 }
 639
 640 /* See gdb_bfd.h.  */
 641
 642 const gdb_byte *
 643 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 644 {
 645   bfd *abfd;
 646   struct gdb_bfd_section_data *descriptor;
 647   bfd_byte *data;
 648
 649   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 650   gdb_assert (size != NULL);
 651
 652   abfd = sectp->owner;
 653
 654   descriptor = get_section_descriptor (sectp);
 655
 656   /* If the data was already read for this BFD, just reuse it.  */
 657   if (descriptor->data != NULL)
 658     goto done;
 659
 660 #ifdef HAVE_MMAP
 661   if (!bfd_is_section_compressed (abfd, sectp))
 662     {
 663       /* The page size, used when mmapping.  */
 664       static int pagesize;
 665
 666       if (pagesize == 0)
 667         pagesize = getpagesize ();
 668
 669       /* Only try to mmap sections which are large enough: we don't want
 670          to waste space due to fragmentation.  */
 671
 672       if (bfd_get_section_size (sectp) > 4 * pagesize)
 673         {
 674           descriptor->size = bfd_get_section_size (sectp);
 675           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 676                                        MAP_PRIVATE, sectp->filepos,
 677                                        &descriptor->map_addr,
 678                                        &descriptor->map_len);
 679
 680           if ((caddr_t)descriptor->data != MAP_FAILED)
 681             {
 682 #if HAVE_POSIX_MADVISE
 683               posix_madvise (descriptor->map_addr, descriptor->map_len,
 684                              POSIX_MADV_WILLNEED);
 685 #endif
 686               goto done;
 687             }
 688
 689           /* On failure, clear out the section data and try again.  */
 690           memset (descriptor, 0, sizeof (*descriptor));
 691         }
 692     }
 693 #endif /* HAVE_MMAP */
 694
 695   /* Handle compressed sections, or ordinary uncompressed sections in
 696      the no-mmap case.  */
 697
 698   descriptor->size = bfd_get_section_size (sectp);
 699   descriptor->data = NULL;
 700
 701   data = NULL;
 702   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 703     error (_("Can't read data for section '%s' in file '%s'"),
 704            bfd_get_section_name (abfd, sectp),
 705            bfd_get_filename (abfd));
 706   descriptor->data = data;
 707
 708  done:
 709   gdb_assert (descriptor->data != NULL);
 710   *size = descriptor->size;
 711   return descriptor->data;
 712 }
 713
 714 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 715    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 716    not preserved.  */
 717
 718 static int
 719 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 720 {
 721   unsigned long file_crc = 0;
 722
 723   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 724     {
 725       warning (_("Problem reading \"%s\" for CRC: %s"),
 726                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 727       return 0;
 728     }
 729
 730   for (;;)
 731     {
 732       gdb_byte buffer[8 * 1024];
 733       bfd_size_type count;
 734
 735       count = bfd_bread (buffer, sizeof (buffer), abfd);
 736       if (count == (bfd_size_type) -1)
 737         {
 738           warning (_("Problem reading \"%s\" for CRC: %s"),
 739                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 740           return 0;
 741         }
 742       if (count == 0)
 743         break;
 744       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 745     }
 746
 747   *file_crc_return = file_crc;
 748   return 1;
 749 }
 750
 751 /* See gdb_bfd.h.  */
 752
 753 int
 754 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 755 {
 756   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 757
 758   if (!gdata->crc_computed)
 759     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 760
 761   if (gdata->crc_computed)
 762     *crc_out = gdata->crc;
 763   return gdata->crc_computed;
 764 }
 765
 766 \f
 767
 768 /* See gdb_bfd.h.  */
 769
 770 bfd *
 771 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 772                int fd)
 773 {
 774   bfd *result = bfd_fopen (filename, target, mode, fd);
 775
 776   if (result)
 777     gdb_bfd_ref (result);
 778
 779   return result;
 780 }
 781
 782 /* See gdb_bfd.h.  */
 783
 784 bfd *
 785 gdb_bfd_openr (const char *filename, const char *target)
 786 {
 787   bfd *result = bfd_openr (filename, target);
 788
 789   if (result)
 790     gdb_bfd_ref (result);
 791
 792   return result;
 793 }
 794
 795 /* See gdb_bfd.h.  */
 796
 797 bfd *
 798 gdb_bfd_openw (const char *filename, const char *target)
 799 {
 800   bfd *result = bfd_openw (filename, target);
 801
 802   if (result)
 803     gdb_bfd_ref (result);
 804
 805   return result;
 806 }
 807
 808 /* See gdb_bfd.h.  */
 809
 810 bfd *
 811 gdb_bfd_openr_iovec (const char *filename, const char *target,
 812                      void *(*open_func) (struct bfd *nbfd,
 813                                          void *open_closure),
 814                      void *open_closure,
 815                      file_ptr (*pread_func) (struct bfd *nbfd,
 816                                              void *stream,
 817                                              void *buf,
 818                                              file_ptr nbytes,
 819                                              file_ptr offset),
 820                      int (*close_func) (struct bfd *nbfd,
 821                                         void *stream),
 822                      int (*stat_func) (struct bfd *abfd,
 823                                        void *stream,
 824                                        struct stat *sb))
 825 {
 826   bfd *result = bfd_openr_iovec (filename, target,
 827                                  open_func, open_closure,
 828                                  pread_func, close_func, stat_func);
 829
 830   if (result)
 831     gdb_bfd_ref (result);
 832
 833   return result;
 834 }
 835
 836 /* See gdb_bfd.h.  */
 837
 838 void
 839 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 840 {
 841   struct gdb_bfd_data *gdata;
 842
 843   gdb_bfd_ref (child);
 844   /* No need to stash the filename here, because we also keep a
 845      reference on the parent archive.  */
 846
 847   gdata = bfd_usrdata (child);
 848   if (gdata->archive_bfd == NULL)
 849     {
 850       gdata->archive_bfd = parent;
 851       gdb_bfd_ref (parent);
 852     }
 853   else
 854     gdb_assert (gdata->archive_bfd == parent);
 855 }
 856
 857 /* See gdb_bfd.h.  */
 858
 859 bfd *
 860 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 861 {
 862   bfd *result = bfd_openr_next_archived_file (archive, previous);
 863
 864   if (result)
 865     gdb_bfd_mark_parent (result, archive);
 866
 867   return result;
 868 }
 869
 870 /* See gdb_bfd.h.  */
 871
 872 void
 873 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 874 {
 875   struct gdb_bfd_data *gdata;
 876
 877   gdb_bfd_ref (includee);
 878   gdata = bfd_usrdata (includer);
 879   VEC_safe_push (bfdp, gdata->included_bfds, includee);
 880 }
 881
 882 /* See gdb_bfd.h.  */
 883
 884 bfd *
 885 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
 886 {
 887   bfd *result = bfd_fdopenr (filename, target, fd);
 888
 889   if (result)
 890     gdb_bfd_ref (result);
 891
 892   return result;
 893 }
 894
 895 \f
 896
 897 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 898
 899 /* See gdb_bfd.h.  */
 900
 901 int
 902 gdb_bfd_section_index (bfd *abfd, asection *section)
 903 {
 904   if (section == NULL)
 905     return -1;
 906   else if (section == bfd_com_section_ptr)
 907     return bfd_count_sections (abfd);
 908   else if (section == bfd_und_section_ptr)
 909     return bfd_count_sections (abfd) + 1;
 910   else if (section == bfd_abs_section_ptr)
 911     return bfd_count_sections (abfd) + 2;
 912   else if (section == bfd_ind_section_ptr)
 913     return bfd_count_sections (abfd) + 3;
 914   return section->index;
 915 }
 916
 917 /* See gdb_bfd.h.  */
 918
 919 int
 920 gdb_bfd_count_sections (bfd *abfd)
 921 {
 922   return bfd_count_sections (abfd) + 4;
 923 }
 924
 925 /* See gdb_bfd.h.  */
 926
 927 int
 928 gdb_bfd_requires_relocations (bfd *abfd)
 929 {
 930   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 931
 932   if (gdata->relocation_computed == 0)
 933     {
 934       asection *sect;
 935
 936       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 937         if ((sect->flags & SEC_RELOC) != 0)
 938           {
 939             gdata->needs_relocations = 1;
 940             break;
 941           }
 942
 943       gdata->relocation_computed = 1;
 944     }
 945
 946   return gdata->needs_relocations;
 947 }
 948
 949 \f
 950
 951 /* A callback for htab_traverse that prints a single BFD.  */
 952
 953 static int
 954 print_one_bfd (void **slot, void *data)
 955 {
 956   bfd *abfd = *slot;
 957   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 958   struct ui_out *uiout = data;
 959   struct cleanup *inner;
 960
 961   inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 962   ui_out_field_int (uiout, "refcount", gdata->refc);
 963   ui_out_field_string (uiout, "addr", host_address_to_string (abfd));
 964   ui_out_field_string (uiout, "filename", bfd_get_filename (abfd));
 965   ui_out_text (uiout, "\n");
 966   do_cleanups (inner);
 967
 968   return 1;
 969 }
 970
 971 /* Implement the 'maint info bfd' command.  */
 972
 973 static void
 974 maintenance_info_bfds (char *arg, int from_tty)
 975 {
 976   struct cleanup *cleanup;
 977   struct ui_out *uiout = current_uiout;
 978
 979   cleanup = make_cleanup_ui_out_table_begin_end (uiout, 3, -1, "bfds");
 980   ui_out_table_header (uiout, 10, ui_left, "refcount", "Refcount");
 981   ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
 982   ui_out_table_header (uiout, 40, ui_left, "filename", "Filename");
 983
 984   ui_out_table_body (uiout);
 985   htab_traverse (all_bfds, print_one_bfd, uiout);
 986
 987   do_cleanups (cleanup);
 988 }
 989
 990 /* -Wmissing-prototypes */
 991 extern initialize_file_ftype _initialize_gdb_bfd;
 992
 993 void
 994 _initialize_gdb_bfd (void)
 995 {
 996   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
 997                                 NULL, xcalloc, xfree);
 998
 999   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
1000 List the BFDs that are currently open."),
1001            &maintenanceinfolist);
1002
1003   add_setshow_boolean_cmd ("bfd-sharing", no_class,
1004                            &bfd_sharing, _("\
1005 Set whether gdb will share bfds that appear to be the same file."), _("\
1006 Show whether gdb will share bfds that appear to be the same file."), _("\
1007 When enabled gdb will reuse existing bfds rather than reopening the\n\
1008 same file.  To decide if two files are the same then gdb compares the\n\
1009 filename, file size, file modification time, and file inode."),
1010                            NULL,
1011                            &show_bfd_sharing,
1012                            &maintenance_set_cmdlist,
1013                            &maintenance_show_cmdlist);
1014
1015   add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
1016                              &debug_bfd_cache, _("\
1017 Set bfd cache debugging."), _("\
1018 Show bfd cache debugging."), _("\
1019 When non-zero, bfd cache specific debugging is enabled."),
1020                              NULL,
1021                              &show_bfd_cache_debug,
1022                              &setdebuglist, &showdebuglist);
1023 }