gdb/gdb_bfd.c

   1 /* Definitions for BFD wrappers used by GDB.
   2
   3    Copyright (C) 2011-2018 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 /* An object of this type is stored in the section's user data when
  38    mapping a section.  */
  39
  40 struct gdb_bfd_section_data
  41 {
  42   /* Size of the data.  */
  43   bfd_size_type size;
  44   /* If the data was mmapped, this is the length of the map.  */
  45   bfd_size_type map_len;
  46   /* The data.  If NULL, the section data has not been read.  */
  47   void *data;
  48   /* If the data was mmapped, this is the map address.  */
  49   void *map_addr;
  50 };
  51
  52 /* A hash table holding every BFD that gdb knows about.  This is not
  53    to be confused with 'gdb_bfd_cache', which is used for sharing
  54    BFDs; in contrast, this hash is used just to implement
  55    "maint info bfd".  */
  56
  57 static htab_t all_bfds;
  58
  59 /* An object of this type is stored in each BFD's user data.  */
  60
  61 struct gdb_bfd_data
  62 {
  63   gdb_bfd_data (bfd *abfd)
  64     : mtime (bfd_get_mtime (abfd)),
  65       size (bfd_get_size (abfd)),
  66       relocation_computed (0),
  67       needs_relocations (0),
  68       crc_computed (0)
  69   {
  70     struct stat buf;
  71
  72     if (bfd_stat (abfd, &buf) == 0)
  73       {
  74         inode = buf.st_ino;
  75         device_id = buf.st_dev;
  76       }
  77     else
  78       {
  79         /* The stat failed.  */
  80         inode = 0;
  81         device_id = 0;
  82       }
  83   }
  84
  85   ~gdb_bfd_data ()
  86   {
  87   }
  88
  89   /* The reference count.  */
  90   int refc = 1;
  91
  92   /* The mtime of the BFD at the point the cache entry was made.  */
  93   time_t mtime;
  94
  95   /* The file size (in bytes) at the point the cache entry was made.  */
  96   off_t size;
  97
  98   /* The inode of the file at the point the cache entry was made.  */
  99   ino_t inode;
 100
 101   /* The device id of the file at the point the cache entry was made.  */
 102   dev_t device_id;
 103
 104   /* This is true if we have determined whether this BFD has any
 105      sections requiring relocation.  */
 106   unsigned int relocation_computed : 1;
 107
 108   /* This is true if any section needs relocation.  */
 109   unsigned int needs_relocations : 1;
 110
 111   /* This is true if we have successfully computed the file's CRC.  */
 112   unsigned int crc_computed : 1;
 113
 114   /* The file's CRC.  */
 115   unsigned long crc = 0;
 116
 117   /* If the BFD comes from an archive, this points to the archive's
 118      BFD.  Otherwise, this is NULL.  */
 119   bfd *archive_bfd = nullptr;
 120
 121   /* Table of all the bfds this bfd has included.  */
 122   std::vector<gdb_bfd_ref_ptr> included_bfds;
 123
 124   /* The registry.  */
 125   REGISTRY_FIELDS = {};
 126 };
 127
 128 #define GDB_BFD_DATA_ACCESSOR(ABFD) \
 129   ((struct gdb_bfd_data *) bfd_usrdata (ABFD))
 130
 131 DEFINE_REGISTRY (bfd, GDB_BFD_DATA_ACCESSOR)
 132
 133 /* A hash table storing all the BFDs maintained in the cache.  */
 134
 135 static htab_t gdb_bfd_cache;
 136
 137 /* When true gdb will reuse an existing bfd object if the filename,
 138    modification time, and file size all match.  */
 139
 140 static int bfd_sharing = 1;
 141 static void
 142 show_bfd_sharing  (struct ui_file *file, int from_tty,
 143                    struct cmd_list_element *c, const char *value)
 144 {
 145   fprintf_filtered (file, _("BFD sharing is %s.\n"), value);
 146 }
 147
 148 /* When non-zero debugging of the bfd caches is enabled.  */
 149
 150 static unsigned int debug_bfd_cache;
 151 static void
 152 show_bfd_cache_debug (struct ui_file *file, int from_tty,
 153                       struct cmd_list_element *c, const char *value)
 154 {
 155   fprintf_filtered (file, _("BFD cache debugging is %s.\n"), value);
 156 }
 157
 158 /* The type of an object being looked up in gdb_bfd_cache.  We use
 159    htab's capability of storing one kind of object (BFD in this case)
 160    and using a different sort of object for searching.  */
 161
 162 struct gdb_bfd_cache_search
 163 {
 164   /* The filename.  */
 165   const char *filename;
 166   /* The mtime.  */
 167   time_t mtime;
 168   /* The file size (in bytes).  */
 169   off_t size;
 170   /* The inode of the file.  */
 171   ino_t inode;
 172   /* The device id of the file.  */
 173   dev_t device_id;
 174 };
 175
 176 /* A hash function for BFDs.  */
 177
 178 static hashval_t
 179 hash_bfd (const void *b)
 180 {
 181   const bfd *abfd = (const struct bfd *) b;
 182
 183   /* It is simplest to just hash the filename.  */
 184   return htab_hash_string (bfd_get_filename (abfd));
 185 }
 186
 187 /* An equality function for BFDs.  Note that this expects the caller
 188    to search using struct gdb_bfd_cache_search only, not BFDs.  */
 189
 190 static int
 191 eq_bfd (const void *a, const void *b)
 192 {
 193   const bfd *abfd = (const struct bfd *) a;
 194   const struct gdb_bfd_cache_search *s
 195     = (const struct gdb_bfd_cache_search *) b;
 196   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 197
 198   return (gdata->mtime == s->mtime
 199           && gdata->size == s->size
 200           && gdata->inode == s->inode
 201           && gdata->device_id == s->device_id
 202           && strcmp (bfd_get_filename (abfd), s->filename) == 0);
 203 }
 204
 205 /* See gdb_bfd.h.  */
 206
 207 int
 208 is_target_filename (const char *name)
 209 {
 210   return startswith (name, TARGET_SYSROOT_PREFIX);
 211 }
 212
 213 /* See gdb_bfd.h.  */
 214
 215 int
 216 gdb_bfd_has_target_filename (struct bfd *abfd)
 217 {
 218   return is_target_filename (bfd_get_filename (abfd));
 219 }
 220
 221
 222 /* Return the system error number corresponding to ERRNUM.  */
 223
 224 static int
 225 fileio_errno_to_host (int errnum)
 226 {
 227   switch (errnum)
 228     {
 229       case FILEIO_EPERM:
 230         return EPERM;
 231       case FILEIO_ENOENT:
 232         return ENOENT;
 233       case FILEIO_EINTR:
 234         return EINTR;
 235       case FILEIO_EIO:
 236         return EIO;
 237       case FILEIO_EBADF:
 238         return EBADF;
 239       case FILEIO_EACCES:
 240         return EACCES;
 241       case FILEIO_EFAULT:
 242         return EFAULT;
 243       case FILEIO_EBUSY:
 244         return EBUSY;
 245       case FILEIO_EEXIST:
 246         return EEXIST;
 247       case FILEIO_ENODEV:
 248         return ENODEV;
 249       case FILEIO_ENOTDIR:
 250         return ENOTDIR;
 251       case FILEIO_EISDIR:
 252         return EISDIR;
 253       case FILEIO_EINVAL:
 254         return EINVAL;
 255       case FILEIO_ENFILE:
 256         return ENFILE;
 257       case FILEIO_EMFILE:
 258         return EMFILE;
 259       case FILEIO_EFBIG:
 260         return EFBIG;
 261       case FILEIO_ENOSPC:
 262         return ENOSPC;
 263       case FILEIO_ESPIPE:
 264         return ESPIPE;
 265       case FILEIO_EROFS:
 266         return EROFS;
 267       case FILEIO_ENOSYS:
 268         return ENOSYS;
 269       case FILEIO_ENAMETOOLONG:
 270         return ENAMETOOLONG;
 271     }
 272   return -1;
 273 }
 274
 275 /* Wrapper for target_fileio_open suitable for passing as the
 276    OPEN_FUNC argument to gdb_bfd_openr_iovec.  The supplied
 277    OPEN_CLOSURE is unused.  */
 278
 279 static void *
 280 gdb_bfd_iovec_fileio_open (struct bfd *abfd, void *inferior)
 281 {
 282   const char *filename = bfd_get_filename (abfd);
 283   int fd, target_errno;
 284   int *stream;
 285
 286   gdb_assert (is_target_filename (filename));
 287
 288   fd = target_fileio_open_warn_if_slow ((struct inferior *) inferior,
 289                                         filename
 290                                         + strlen (TARGET_SYSROOT_PREFIX),
 291                                         FILEIO_O_RDONLY, 0,
 292                                         &target_errno);
 293   if (fd == -1)
 294     {
 295       errno = fileio_errno_to_host (target_errno);
 296       bfd_set_error (bfd_error_system_call);
 297       return NULL;
 298     }
 299
 300   stream = XCNEW (int);
 301   *stream = fd;
 302   return stream;
 303 }
 304
 305 /* Wrapper for target_fileio_pread suitable for passing as the
 306    PREAD_FUNC argument to gdb_bfd_openr_iovec.  */
 307
 308 static file_ptr
 309 gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf,
 310                             file_ptr nbytes, file_ptr offset)
 311 {
 312   int fd = *(int *) stream;
 313   int target_errno;
 314   file_ptr pos, bytes;
 315
 316   pos = 0;
 317   while (nbytes > pos)
 318     {
 319       QUIT;
 320
 321       bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos,
 322                                    nbytes - pos, offset + pos,
 323                                    &target_errno);
 324       if (bytes == 0)
 325         /* Success, but no bytes, means end-of-file.  */
 326         break;
 327       if (bytes == -1)
 328         {
 329           errno = fileio_errno_to_host (target_errno);
 330           bfd_set_error (bfd_error_system_call);
 331           return -1;
 332         }
 333
 334       pos += bytes;
 335     }
 336
 337   return pos;
 338 }
 339
 340 /* Wrapper for target_fileio_close suitable for passing as the
 341    CLOSE_FUNC argument to gdb_bfd_openr_iovec.  */
 342
 343 static int
 344 gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream)
 345 {
 346   int fd = *(int *) stream;
 347   int target_errno;
 348
 349   xfree (stream);
 350
 351   /* Ignore errors on close.  These may happen with remote
 352      targets if the connection has already been torn down.  */
 353   target_fileio_close (fd, &target_errno);
 354
 355   /* Zero means success.  */
 356   return 0;
 357 }
 358
 359 /* Wrapper for target_fileio_fstat suitable for passing as the
 360    STAT_FUNC argument to gdb_bfd_openr_iovec.  */
 361
 362 static int
 363 gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream,
 364                             struct stat *sb)
 365 {
 366   int fd = *(int *) stream;
 367   int target_errno;
 368   int result;
 369
 370   result = target_fileio_fstat (fd, sb, &target_errno);
 371   if (result == -1)
 372     {
 373       errno = fileio_errno_to_host (target_errno);
 374       bfd_set_error (bfd_error_system_call);
 375     }
 376
 377   return result;
 378 }
 379
 380 /* See gdb_bfd.h.  */
 381
 382 gdb_bfd_ref_ptr
 383 gdb_bfd_open (const char *name, const char *target, int fd)
 384 {
 385   hashval_t hash;
 386   void **slot;
 387   bfd *abfd;
 388   struct gdb_bfd_cache_search search;
 389   struct stat st;
 390
 391   if (is_target_filename (name))
 392     {
 393       if (!target_filesystem_is_local ())
 394         {
 395           gdb_assert (fd == -1);
 396
 397           return gdb_bfd_openr_iovec (name, target,
 398                                       gdb_bfd_iovec_fileio_open,
 399                                       current_inferior (),
 400                                       gdb_bfd_iovec_fileio_pread,
 401                                       gdb_bfd_iovec_fileio_close,
 402                                       gdb_bfd_iovec_fileio_fstat);
 403         }
 404
 405       name += strlen (TARGET_SYSROOT_PREFIX);
 406     }
 407
 408   if (gdb_bfd_cache == NULL)
 409     gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
 410                                        xcalloc, xfree);
 411
 412   if (fd == -1)
 413     {
 414       fd = gdb_open_cloexec (name, O_RDONLY | O_BINARY, 0);
 415       if (fd == -1)
 416         {
 417           bfd_set_error (bfd_error_system_call);
 418           return NULL;
 419         }
 420     }
 421
 422   search.filename = name;
 423   if (fstat (fd, &st) < 0)
 424     {
 425       /* Weird situation here.  */
 426       search.mtime = 0;
 427       search.size = 0;
 428       search.inode = 0;
 429       search.device_id = 0;
 430     }
 431   else
 432     {
 433       search.mtime = st.st_mtime;
 434       search.size = st.st_size;
 435       search.inode = st.st_ino;
 436       search.device_id = st.st_dev;
 437     }
 438
 439   /* Note that this must compute the same result as hash_bfd.  */
 440   hash = htab_hash_string (name);
 441   /* Note that we cannot use htab_find_slot_with_hash here, because
 442      opening the BFD may fail; and this would violate hashtab
 443      invariants.  */
 444   abfd = (struct bfd *) htab_find_with_hash (gdb_bfd_cache, &search, hash);
 445   if (bfd_sharing && abfd != NULL)
 446     {
 447       if (debug_bfd_cache)
 448         fprintf_unfiltered (gdb_stdlog,
 449                             "Reusing cached bfd %s for %s\n",
 450                             host_address_to_string (abfd),
 451                             bfd_get_filename (abfd));
 452       close (fd);
 453       return new_bfd_ref (abfd);
 454     }
 455
 456   abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 457   if (abfd == NULL)
 458     return NULL;
 459
 460   if (debug_bfd_cache)
 461     fprintf_unfiltered (gdb_stdlog,
 462                         "Creating new bfd %s for %s\n",
 463                         host_address_to_string (abfd),
 464                         bfd_get_filename (abfd));
 465
 466   if (bfd_sharing)
 467     {
 468       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
 469       gdb_assert (!*slot);
 470       *slot = abfd;
 471     }
 472
 473   return new_bfd_ref (abfd);
 474 }
 475
 476 /* A helper function that releases any section data attached to the
 477    BFD.  */
 478
 479 static void
 480 free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
 481 {
 482   struct gdb_bfd_section_data *sect
 483     = (struct gdb_bfd_section_data *) bfd_get_section_userdata (abfd, sectp);
 484
 485   if (sect != NULL && sect->data != NULL)
 486     {
 487 #ifdef HAVE_MMAP
 488       if (sect->map_addr != NULL)
 489         {
 490           int res;
 491
 492           res = munmap (sect->map_addr, sect->map_len);
 493           gdb_assert (res == 0);
 494         }
 495       else
 496 #endif
 497         xfree (sect->data);
 498     }
 499 }
 500
 501 /* Close ABFD, and warn if that fails.  */
 502
 503 static int
 504 gdb_bfd_close_or_warn (struct bfd *abfd)
 505 {
 506   int ret;
 507   char *name = bfd_get_filename (abfd);
 508
 509   bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
 510
 511   ret = bfd_close (abfd);
 512
 513   if (!ret)
 514     warning (_("cannot close \"%s\": %s"),
 515              name, bfd_errmsg (bfd_get_error ()));
 516
 517   return ret;
 518 }
 519
 520 /* See gdb_bfd.h.  */
 521
 522 void
 523 gdb_bfd_ref (struct bfd *abfd)
 524 {
 525   struct gdb_bfd_data *gdata;
 526   void **slot;
 527
 528   if (abfd == NULL)
 529     return;
 530
 531   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 532
 533   if (debug_bfd_cache)
 534     fprintf_unfiltered (gdb_stdlog,
 535                         "Increase reference count on bfd %s (%s)\n",
 536                         host_address_to_string (abfd),
 537                         bfd_get_filename (abfd));
 538
 539   if (gdata != NULL)
 540     {
 541       gdata->refc += 1;
 542       return;
 543     }
 544
 545   /* Ask BFD to decompress sections in bfd_get_full_section_contents.  */
 546   abfd->flags |= BFD_DECOMPRESS;
 547
 548   gdata = new gdb_bfd_data (abfd);
 549   bfd_usrdata (abfd) = gdata;
 550   bfd_alloc_data (abfd);
 551
 552   /* This is the first we've seen it, so add it to the hash table.  */
 553   slot = htab_find_slot (all_bfds, abfd, INSERT);
 554   gdb_assert (slot && !*slot);
 555   *slot = abfd;
 556 }
 557
 558 /* See gdb_bfd.h.  */
 559
 560 void
 561 gdb_bfd_unref (struct bfd *abfd)
 562 {
 563   struct gdb_bfd_data *gdata;
 564   struct gdb_bfd_cache_search search;
 565   bfd *archive_bfd;
 566
 567   if (abfd == NULL)
 568     return;
 569
 570   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 571   gdb_assert (gdata->refc >= 1);
 572
 573   gdata->refc -= 1;
 574   if (gdata->refc > 0)
 575     {
 576       if (debug_bfd_cache)
 577         fprintf_unfiltered (gdb_stdlog,
 578                             "Decrease reference count on bfd %s (%s)\n",
 579                             host_address_to_string (abfd),
 580                             bfd_get_filename (abfd));
 581       return;
 582     }
 583
 584   if (debug_bfd_cache)
 585     fprintf_unfiltered (gdb_stdlog,
 586                         "Delete final reference count on bfd %s (%s)\n",
 587                         host_address_to_string (abfd),
 588                         bfd_get_filename (abfd));
 589
 590   archive_bfd = gdata->archive_bfd;
 591   search.filename = bfd_get_filename (abfd);
 592
 593   if (gdb_bfd_cache && search.filename)
 594     {
 595       hashval_t hash = htab_hash_string (search.filename);
 596       void **slot;
 597
 598       search.mtime = gdata->mtime;
 599       search.size = gdata->size;
 600       search.inode = gdata->inode;
 601       search.device_id = gdata->device_id;
 602       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 603                                        NO_INSERT);
 604
 605       if (slot && *slot)
 606         htab_clear_slot (gdb_bfd_cache, slot);
 607     }
 608
 609   bfd_free_data (abfd);
 610   delete gdata;
 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 = ((struct gdb_bfd_section_data *)
 630             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 (const gdb_byte *) 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 = (struct gdb_bfd_data *) 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 gdb_bfd_ref_ptr
 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   return new_bfd_ref (result);
 779 }
 780
 781 /* See gdb_bfd.h.  */
 782
 783 gdb_bfd_ref_ptr
 784 gdb_bfd_openr (const char *filename, const char *target)
 785 {
 786   bfd *result = bfd_openr (filename, target);
 787
 788   return new_bfd_ref (result);
 789 }
 790
 791 /* See gdb_bfd.h.  */
 792
 793 gdb_bfd_ref_ptr
 794 gdb_bfd_openw (const char *filename, const char *target)
 795 {
 796   bfd *result = bfd_openw (filename, target);
 797
 798   return new_bfd_ref (result);
 799 }
 800
 801 /* See gdb_bfd.h.  */
 802
 803 gdb_bfd_ref_ptr
 804 gdb_bfd_openr_iovec (const char *filename, const char *target,
 805                      void *(*open_func) (struct bfd *nbfd,
 806                                          void *open_closure),
 807                      void *open_closure,
 808                      file_ptr (*pread_func) (struct bfd *nbfd,
 809                                              void *stream,
 810                                              void *buf,
 811                                              file_ptr nbytes,
 812                                              file_ptr offset),
 813                      int (*close_func) (struct bfd *nbfd,
 814                                         void *stream),
 815                      int (*stat_func) (struct bfd *abfd,
 816                                        void *stream,
 817                                        struct stat *sb))
 818 {
 819   bfd *result = bfd_openr_iovec (filename, target,
 820                                  open_func, open_closure,
 821                                  pread_func, close_func, stat_func);
 822
 823   return new_bfd_ref (result);
 824 }
 825
 826 /* See gdb_bfd.h.  */
 827
 828 void
 829 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 830 {
 831   struct gdb_bfd_data *gdata;
 832
 833   gdb_bfd_ref (child);
 834   /* No need to stash the filename here, because we also keep a
 835      reference on the parent archive.  */
 836
 837   gdata = (struct gdb_bfd_data *) bfd_usrdata (child);
 838   if (gdata->archive_bfd == NULL)
 839     {
 840       gdata->archive_bfd = parent;
 841       gdb_bfd_ref (parent);
 842     }
 843   else
 844     gdb_assert (gdata->archive_bfd == parent);
 845 }
 846
 847 /* See gdb_bfd.h.  */
 848
 849 gdb_bfd_ref_ptr
 850 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 851 {
 852   bfd *result = bfd_openr_next_archived_file (archive, previous);
 853
 854   if (result)
 855     gdb_bfd_mark_parent (result, archive);
 856
 857   return gdb_bfd_ref_ptr (result);
 858 }
 859
 860 /* See gdb_bfd.h.  */
 861
 862 void
 863 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 864 {
 865   struct gdb_bfd_data *gdata;
 866
 867   gdata = (struct gdb_bfd_data *) bfd_usrdata (includer);
 868   gdata->included_bfds.push_back (new_bfd_ref (includee));
 869 }
 870
 871 /* See gdb_bfd.h.  */
 872
 873 gdb_bfd_ref_ptr
 874 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
 875 {
 876   bfd *result = bfd_fdopenr (filename, target, fd);
 877
 878   return new_bfd_ref (result);
 879 }
 880
 881 \f
 882
 883 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 884
 885 /* See gdb_bfd.h.  */
 886
 887 int
 888 gdb_bfd_section_index (bfd *abfd, asection *section)
 889 {
 890   if (section == NULL)
 891     return -1;
 892   else if (section == bfd_com_section_ptr)
 893     return bfd_count_sections (abfd);
 894   else if (section == bfd_und_section_ptr)
 895     return bfd_count_sections (abfd) + 1;
 896   else if (section == bfd_abs_section_ptr)
 897     return bfd_count_sections (abfd) + 2;
 898   else if (section == bfd_ind_section_ptr)
 899     return bfd_count_sections (abfd) + 3;
 900   return section->index;
 901 }
 902
 903 /* See gdb_bfd.h.  */
 904
 905 int
 906 gdb_bfd_count_sections (bfd *abfd)
 907 {
 908   return bfd_count_sections (abfd) + 4;
 909 }
 910
 911 /* See gdb_bfd.h.  */
 912
 913 int
 914 gdb_bfd_requires_relocations (bfd *abfd)
 915 {
 916   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 917
 918   if (gdata->relocation_computed == 0)
 919     {
 920       asection *sect;
 921
 922       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 923         if ((sect->flags & SEC_RELOC) != 0)
 924           {
 925             gdata->needs_relocations = 1;
 926             break;
 927           }
 928
 929       gdata->relocation_computed = 1;
 930     }
 931
 932   return gdata->needs_relocations;
 933 }
 934
 935 \f
 936
 937 /* A callback for htab_traverse that prints a single BFD.  */
 938
 939 static int
 940 print_one_bfd (void **slot, void *data)
 941 {
 942   bfd *abfd = (struct bfd *) *slot;
 943   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 944   struct ui_out *uiout = (struct ui_out *) data;
 945
 946   ui_out_emit_tuple tuple_emitter (uiout, NULL);
 947   uiout->field_int ("refcount", gdata->refc);
 948   uiout->field_string ("addr", host_address_to_string (abfd));
 949   uiout->field_string ("filename", bfd_get_filename (abfd));
 950   uiout->text ("\n");
 951
 952   return 1;
 953 }
 954
 955 /* Implement the 'maint info bfd' command.  */
 956
 957 static void
 958 maintenance_info_bfds (const char *arg, int from_tty)
 959 {
 960   struct ui_out *uiout = current_uiout;
 961
 962   ui_out_emit_table table_emitter (uiout, 3, -1, "bfds");
 963   uiout->table_header (10, ui_left, "refcount", "Refcount");
 964   uiout->table_header (18, ui_left, "addr", "Address");
 965   uiout->table_header (40, ui_left, "filename", "Filename");
 966
 967   uiout->table_body ();
 968   htab_traverse (all_bfds, print_one_bfd, uiout);
 969 }
 970
 971 void
 972 _initialize_gdb_bfd (void)
 973 {
 974   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
 975                                 NULL, xcalloc, xfree);
 976
 977   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
 978 List the BFDs that are currently open."),
 979            &maintenanceinfolist);
 980
 981   add_setshow_boolean_cmd ("bfd-sharing", no_class,
 982                            &bfd_sharing, _("\
 983 Set whether gdb will share bfds that appear to be the same file."), _("\
 984 Show whether gdb will share bfds that appear to be the same file."), _("\
 985 When enabled gdb will reuse existing bfds rather than reopening the\n\
 986 same file.  To decide if two files are the same then gdb compares the\n\
 987 filename, file size, file modification time, and file inode."),
 988                            NULL,
 989                            &show_bfd_sharing,
 990                            &maintenance_set_cmdlist,
 991                            &maintenance_show_cmdlist);
 992
 993   add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
 994                              &debug_bfd_cache, _("\
 995 Set bfd cache debugging."), _("\
 996 Show bfd cache debugging."), _("\
 997 When non-zero, bfd cache specific debugging is enabled."),
 998                              NULL,
 999                              &show_bfd_cache_debug,
1000                              &setdebuglist, &showdebuglist);
1001 }