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
 527     = (struct gdb_bfd_data *) bfd_zalloc (abfd, sizeof (struct gdb_bfd_data));
 528   gdata->refc = 1;
 529   gdata->mtime = bfd_get_mtime (abfd);
 530   gdata->size = bfd_get_size (abfd);
 531   gdata->archive_bfd = NULL;
 532   if (bfd_stat (abfd, &buf) == 0)
 533     {
 534       gdata->inode = buf.st_ino;
 535       gdata->device_id = buf.st_dev;
 536     }
 537   else
 538     {
 539       /* The stat failed.  */
 540       gdata->inode = 0;
 541       gdata->device_id = 0;
 542     }
 543   bfd_usrdata (abfd) = gdata;
 544
 545   bfd_alloc_data (abfd);
 546
 547   /* This is the first we've seen it, so add it to the hash table.  */
 548   slot = htab_find_slot (all_bfds, abfd, INSERT);
 549   gdb_assert (slot && !*slot);
 550   *slot = abfd;
 551 }
 552
 553 /* See gdb_bfd.h.  */
 554
 555 void
 556 gdb_bfd_unref (struct bfd *abfd)
 557 {
 558   int ix;
 559   struct gdb_bfd_data *gdata;
 560   struct gdb_bfd_cache_search search;
 561   bfd *archive_bfd, *included_bfd;
 562
 563   if (abfd == NULL)
 564     return;
 565
 566   gdata = bfd_usrdata (abfd);
 567   gdb_assert (gdata->refc >= 1);
 568
 569   gdata->refc -= 1;
 570   if (gdata->refc > 0)
 571     {
 572       if (debug_bfd_cache)
 573         fprintf_unfiltered (gdb_stdlog,
 574                             "Decrease reference count on bfd %s (%s)\n",
 575                             host_address_to_string (abfd),
 576                             bfd_get_filename (abfd));
 577       return;
 578     }
 579
 580   if (debug_bfd_cache)
 581     fprintf_unfiltered (gdb_stdlog,
 582                         "Delete final reference count on bfd %s (%s)\n",
 583                         host_address_to_string (abfd),
 584                         bfd_get_filename (abfd));
 585
 586   archive_bfd = gdata->archive_bfd;
 587   search.filename = bfd_get_filename (abfd);
 588
 589   if (gdb_bfd_cache && search.filename)
 590     {
 591       hashval_t hash = htab_hash_string (search.filename);
 592       void **slot;
 593
 594       search.mtime = gdata->mtime;
 595       search.size = gdata->size;
 596       search.inode = gdata->inode;
 597       search.device_id = gdata->device_id;
 598       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 599                                        NO_INSERT);
 600
 601       if (slot && *slot)
 602         htab_clear_slot (gdb_bfd_cache, slot);
 603     }
 604
 605   for (ix = 0;
 606        VEC_iterate (bfdp, gdata->included_bfds, ix, included_bfd);
 607        ++ix)
 608     gdb_bfd_unref (included_bfd);
 609   VEC_free (bfdp, gdata->included_bfds);
 610
 611   bfd_free_data (abfd);
 612   bfd_usrdata (abfd) = NULL;  /* Paranoia.  */
 613
 614   htab_remove_elt (all_bfds, abfd);
 615
 616   gdb_bfd_close_or_warn (abfd);
 617
 618   gdb_bfd_unref (archive_bfd);
 619 }
 620
 621 /* A helper function that returns the section data descriptor
 622    associated with SECTION.  If no such descriptor exists, a new one
 623    is allocated and cleared.  */
 624
 625 static struct gdb_bfd_section_data *
 626 get_section_descriptor (asection *section)
 627 {
 628   struct gdb_bfd_section_data *result;
 629
 630   result = bfd_get_section_userdata (section->owner, section);
 631
 632   if (result == NULL)
 633     {
 634       result = ((struct gdb_bfd_section_data *)
 635                 bfd_zalloc (section->owner, sizeof (*result)));
 636       bfd_set_section_userdata (section->owner, section, result);
 637     }
 638
 639   return result;
 640 }
 641
 642 /* See gdb_bfd.h.  */
 643
 644 const gdb_byte *
 645 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 646 {
 647   bfd *abfd;
 648   struct gdb_bfd_section_data *descriptor;
 649   bfd_byte *data;
 650
 651   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 652   gdb_assert (size != NULL);
 653
 654   abfd = sectp->owner;
 655
 656   descriptor = get_section_descriptor (sectp);
 657
 658   /* If the data was already read for this BFD, just reuse it.  */
 659   if (descriptor->data != NULL)
 660     goto done;
 661
 662 #ifdef HAVE_MMAP
 663   if (!bfd_is_section_compressed (abfd, sectp))
 664     {
 665       /* The page size, used when mmapping.  */
 666       static int pagesize;
 667
 668       if (pagesize == 0)
 669         pagesize = getpagesize ();
 670
 671       /* Only try to mmap sections which are large enough: we don't want
 672          to waste space due to fragmentation.  */
 673
 674       if (bfd_get_section_size (sectp) > 4 * pagesize)
 675         {
 676           descriptor->size = bfd_get_section_size (sectp);
 677           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 678                                        MAP_PRIVATE, sectp->filepos,
 679                                        &descriptor->map_addr,
 680                                        &descriptor->map_len);
 681
 682           if ((caddr_t)descriptor->data != MAP_FAILED)
 683             {
 684 #if HAVE_POSIX_MADVISE
 685               posix_madvise (descriptor->map_addr, descriptor->map_len,
 686                              POSIX_MADV_WILLNEED);
 687 #endif
 688               goto done;
 689             }
 690
 691           /* On failure, clear out the section data and try again.  */
 692           memset (descriptor, 0, sizeof (*descriptor));
 693         }
 694     }
 695 #endif /* HAVE_MMAP */
 696
 697   /* Handle compressed sections, or ordinary uncompressed sections in
 698      the no-mmap case.  */
 699
 700   descriptor->size = bfd_get_section_size (sectp);
 701   descriptor->data = NULL;
 702
 703   data = NULL;
 704   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 705     error (_("Can't read data for section '%s' in file '%s'"),
 706            bfd_get_section_name (abfd, sectp),
 707            bfd_get_filename (abfd));
 708   descriptor->data = data;
 709
 710  done:
 711   gdb_assert (descriptor->data != NULL);
 712   *size = descriptor->size;
 713   return descriptor->data;
 714 }
 715
 716 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 717    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 718    not preserved.  */
 719
 720 static int
 721 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 722 {
 723   unsigned long file_crc = 0;
 724
 725   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 726     {
 727       warning (_("Problem reading \"%s\" for CRC: %s"),
 728                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 729       return 0;
 730     }
 731
 732   for (;;)
 733     {
 734       gdb_byte buffer[8 * 1024];
 735       bfd_size_type count;
 736
 737       count = bfd_bread (buffer, sizeof (buffer), abfd);
 738       if (count == (bfd_size_type) -1)
 739         {
 740           warning (_("Problem reading \"%s\" for CRC: %s"),
 741                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 742           return 0;
 743         }
 744       if (count == 0)
 745         break;
 746       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 747     }
 748
 749   *file_crc_return = file_crc;
 750   return 1;
 751 }
 752
 753 /* See gdb_bfd.h.  */
 754
 755 int
 756 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 757 {
 758   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 759
 760   if (!gdata->crc_computed)
 761     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 762
 763   if (gdata->crc_computed)
 764     *crc_out = gdata->crc;
 765   return gdata->crc_computed;
 766 }
 767
 768 \f
 769
 770 /* See gdb_bfd.h.  */
 771
 772 bfd *
 773 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 774                int fd)
 775 {
 776   bfd *result = bfd_fopen (filename, target, mode, fd);
 777
 778   if (result)
 779     gdb_bfd_ref (result);
 780
 781   return result;
 782 }
 783
 784 /* See gdb_bfd.h.  */
 785
 786 bfd *
 787 gdb_bfd_openr (const char *filename, const char *target)
 788 {
 789   bfd *result = bfd_openr (filename, target);
 790
 791   if (result)
 792     gdb_bfd_ref (result);
 793
 794   return result;
 795 }
 796
 797 /* See gdb_bfd.h.  */
 798
 799 bfd *
 800 gdb_bfd_openw (const char *filename, const char *target)
 801 {
 802   bfd *result = bfd_openw (filename, target);
 803
 804   if (result)
 805     gdb_bfd_ref (result);
 806
 807   return result;
 808 }
 809
 810 /* See gdb_bfd.h.  */
 811
 812 bfd *
 813 gdb_bfd_openr_iovec (const char *filename, const char *target,
 814                      void *(*open_func) (struct bfd *nbfd,
 815                                          void *open_closure),
 816                      void *open_closure,
 817                      file_ptr (*pread_func) (struct bfd *nbfd,
 818                                              void *stream,
 819                                              void *buf,
 820                                              file_ptr nbytes,
 821                                              file_ptr offset),
 822                      int (*close_func) (struct bfd *nbfd,
 823                                         void *stream),
 824                      int (*stat_func) (struct bfd *abfd,
 825                                        void *stream,
 826                                        struct stat *sb))
 827 {
 828   bfd *result = bfd_openr_iovec (filename, target,
 829                                  open_func, open_closure,
 830                                  pread_func, close_func, stat_func);
 831
 832   if (result)
 833     gdb_bfd_ref (result);
 834
 835   return result;
 836 }
 837
 838 /* See gdb_bfd.h.  */
 839
 840 void
 841 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 842 {
 843   struct gdb_bfd_data *gdata;
 844
 845   gdb_bfd_ref (child);
 846   /* No need to stash the filename here, because we also keep a
 847      reference on the parent archive.  */
 848
 849   gdata = bfd_usrdata (child);
 850   if (gdata->archive_bfd == NULL)
 851     {
 852       gdata->archive_bfd = parent;
 853       gdb_bfd_ref (parent);
 854     }
 855   else
 856     gdb_assert (gdata->archive_bfd == parent);
 857 }
 858
 859 /* See gdb_bfd.h.  */
 860
 861 bfd *
 862 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 863 {
 864   bfd *result = bfd_openr_next_archived_file (archive, previous);
 865
 866   if (result)
 867     gdb_bfd_mark_parent (result, archive);
 868
 869   return result;
 870 }
 871
 872 /* See gdb_bfd.h.  */
 873
 874 void
 875 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 876 {
 877   struct gdb_bfd_data *gdata;
 878
 879   gdb_bfd_ref (includee);
 880   gdata = bfd_usrdata (includer);
 881   VEC_safe_push (bfdp, gdata->included_bfds, includee);
 882 }
 883
 884 /* See gdb_bfd.h.  */
 885
 886 bfd *
 887 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
 888 {
 889   bfd *result = bfd_fdopenr (filename, target, fd);
 890
 891   if (result)
 892     gdb_bfd_ref (result);
 893
 894   return result;
 895 }
 896
 897 \f
 898
 899 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 900
 901 /* See gdb_bfd.h.  */
 902
 903 int
 904 gdb_bfd_section_index (bfd *abfd, asection *section)
 905 {
 906   if (section == NULL)
 907     return -1;
 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;
 917 }
 918
 919 /* See gdb_bfd.h.  */
 920
 921 int
 922 gdb_bfd_count_sections (bfd *abfd)
 923 {
 924   return bfd_count_sections (abfd) + 4;
 925 }
 926
 927 /* See gdb_bfd.h.  */
 928
 929 int
 930 gdb_bfd_requires_relocations (bfd *abfd)
 931 {
 932   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 933
 934   if (gdata->relocation_computed == 0)
 935     {
 936       asection *sect;
 937
 938       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 939         if ((sect->flags & SEC_RELOC) != 0)
 940           {
 941             gdata->needs_relocations = 1;
 942             break;
 943           }
 944
 945       gdata->relocation_computed = 1;
 946     }
 947
 948   return gdata->needs_relocations;
 949 }
 950
 951 \f
 952
 953 /* A callback for htab_traverse that prints a single BFD.  */
 954
 955 static int
 956 print_one_bfd (void **slot, void *data)
 957 {
 958   bfd *abfd = *slot;
 959   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 960   struct ui_out *uiout = data;
 961   struct cleanup *inner;
 962
 963   inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 964   ui_out_field_int (uiout, "refcount", gdata->refc);
 965   ui_out_field_string (uiout, "addr", host_address_to_string (abfd));
 966   ui_out_field_string (uiout, "filename", bfd_get_filename (abfd));
 967   ui_out_text (uiout, "\n");
 968   do_cleanups (inner);
 969
 970   return 1;
 971 }
 972
 973 /* Implement the 'maint info bfd' command.  */
 974
 975 static void
 976 maintenance_info_bfds (char *arg, int from_tty)
 977 {
 978   struct cleanup *cleanup;
 979   struct ui_out *uiout = current_uiout;
 980
 981   cleanup = make_cleanup_ui_out_table_begin_end (uiout, 3, -1, "bfds");
 982   ui_out_table_header (uiout, 10, ui_left, "refcount", "Refcount");
 983   ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
 984   ui_out_table_header (uiout, 40, ui_left, "filename", "Filename");
 985
 986   ui_out_table_body (uiout);
 987   htab_traverse (all_bfds, print_one_bfd, uiout);
 988
 989   do_cleanups (cleanup);
 990 }
 991
 992 /* -Wmissing-prototypes */
 993 extern initialize_file_ftype _initialize_gdb_bfd;
 994
 995 void
 996 _initialize_gdb_bfd (void)
 997 {
 998   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
 999                                 NULL, xcalloc, xfree);
1000
1001   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
1002 List the BFDs that are currently open."),
1003            &maintenanceinfolist);
1004
1005   add_setshow_boolean_cmd ("bfd-sharing", no_class,
1006                            &bfd_sharing, _("\
1007 Set whether gdb will share bfds that appear to be the same file."), _("\
1008 Show whether gdb will share bfds that appear to be the same file."), _("\
1009 When enabled gdb will reuse existing bfds rather than reopening the\n\
1010 same file.  To decide if two files are the same then gdb compares the\n\
1011 filename, file size, file modification time, and file inode."),
1012                            NULL,
1013                            &show_bfd_sharing,
1014                            &maintenance_set_cmdlist,
1015                            &maintenance_show_cmdlist);
1016
1017   add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
1018                              &debug_bfd_cache, _("\
1019 Set bfd cache debugging."), _("\
1020 Show bfd cache debugging."), _("\
1021 When non-zero, bfd cache specific debugging is enabled."),
1022                              NULL,
1023                              &show_bfd_cache_debug,
1024                              &setdebuglist, &showdebuglist);
1025 }