gdb/gdb_bfd.c

   1 /* Definitions for BFD wrappers used by GDB.
   2
   3    Copyright (C) 2011-2019 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 "gdbsupport/filestuff.h"
  26 #include "gdbsupport/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 bool bfd_sharing = true;
 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 gdb_bfd_ref_ptr::new_reference (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 gdb_bfd_ref_ptr::new_reference (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_section_userdata (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   const 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 *) bfd_section_userdata (section);
 630
 631   if (result == NULL)
 632     {
 633       result = ((struct gdb_bfd_section_data *)
 634                 bfd_zalloc (section->owner, sizeof (*result)));
 635       bfd_set_section_userdata (section, result);
 636     }
 637
 638   return result;
 639 }
 640
 641 /* See gdb_bfd.h.  */
 642
 643 const gdb_byte *
 644 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 645 {
 646   bfd *abfd;
 647   struct gdb_bfd_section_data *descriptor;
 648   bfd_byte *data;
 649
 650   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 651   gdb_assert (size != NULL);
 652
 653   abfd = sectp->owner;
 654
 655   descriptor = get_section_descriptor (sectp);
 656
 657   /* If the data was already read for this BFD, just reuse it.  */
 658   if (descriptor->data != NULL)
 659     goto done;
 660
 661 #ifdef HAVE_MMAP
 662   if (!bfd_is_section_compressed (abfd, sectp))
 663     {
 664       /* The page size, used when mmapping.  */
 665       static int pagesize;
 666
 667       if (pagesize == 0)
 668         pagesize = getpagesize ();
 669
 670       /* Only try to mmap sections which are large enough: we don't want
 671          to waste space due to fragmentation.  */
 672
 673       if (bfd_section_size (sectp) > 4 * pagesize)
 674         {
 675           descriptor->size = bfd_section_size (sectp);
 676           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 677                                        MAP_PRIVATE, sectp->filepos,
 678                                        &descriptor->map_addr,
 679                                        &descriptor->map_len);
 680
 681           if ((caddr_t)descriptor->data != MAP_FAILED)
 682             {
 683 #if HAVE_POSIX_MADVISE
 684               posix_madvise (descriptor->map_addr, descriptor->map_len,
 685                              POSIX_MADV_WILLNEED);
 686 #endif
 687               goto done;
 688             }
 689
 690           /* On failure, clear out the section data and try again.  */
 691           memset (descriptor, 0, sizeof (*descriptor));
 692         }
 693     }
 694 #endif /* HAVE_MMAP */
 695
 696   /* Handle compressed sections, or ordinary uncompressed sections in
 697      the no-mmap case.  */
 698
 699   descriptor->size = bfd_section_size (sectp);
 700   descriptor->data = NULL;
 701
 702   data = NULL;
 703   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 704     {
 705       warning (_("Can't read data for section '%s' in file '%s'"),
 706                bfd_section_name (sectp),
 707                bfd_get_filename (abfd));
 708       /* Set size to 0 to prevent further attempts to read the invalid
 709          section.  */
 710       *size = 0;
 711       return NULL;
 712     }
 713   descriptor->data = data;
 714
 715  done:
 716   gdb_assert (descriptor->data != NULL);
 717   *size = descriptor->size;
 718   return (const gdb_byte *) descriptor->data;
 719 }
 720
 721 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 722    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 723    not preserved.  */
 724
 725 static int
 726 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 727 {
 728   unsigned long file_crc = 0;
 729
 730   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 731     {
 732       warning (_("Problem reading \"%s\" for CRC: %s"),
 733                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 734       return 0;
 735     }
 736
 737   for (;;)
 738     {
 739       gdb_byte buffer[8 * 1024];
 740       bfd_size_type count;
 741
 742       count = bfd_bread (buffer, sizeof (buffer), abfd);
 743       if (count == (bfd_size_type) -1)
 744         {
 745           warning (_("Problem reading \"%s\" for CRC: %s"),
 746                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 747           return 0;
 748         }
 749       if (count == 0)
 750         break;
 751       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 752     }
 753
 754   *file_crc_return = file_crc;
 755   return 1;
 756 }
 757
 758 /* See gdb_bfd.h.  */
 759
 760 int
 761 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 762 {
 763   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 764
 765   if (!gdata->crc_computed)
 766     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 767
 768   if (gdata->crc_computed)
 769     *crc_out = gdata->crc;
 770   return gdata->crc_computed;
 771 }
 772
 773 \f
 774
 775 /* See gdb_bfd.h.  */
 776
 777 gdb_bfd_ref_ptr
 778 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 779                int fd)
 780 {
 781   bfd *result = bfd_fopen (filename, target, mode, fd);
 782
 783   return gdb_bfd_ref_ptr::new_reference (result);
 784 }
 785
 786 /* See gdb_bfd.h.  */
 787
 788 gdb_bfd_ref_ptr
 789 gdb_bfd_openr (const char *filename, const char *target)
 790 {
 791   bfd *result = bfd_openr (filename, target);
 792
 793   return gdb_bfd_ref_ptr::new_reference (result);
 794 }
 795
 796 /* See gdb_bfd.h.  */
 797
 798 gdb_bfd_ref_ptr
 799 gdb_bfd_openw (const char *filename, const char *target)
 800 {
 801   bfd *result = bfd_openw (filename, target);
 802
 803   return gdb_bfd_ref_ptr::new_reference (result);
 804 }
 805
 806 /* See gdb_bfd.h.  */
 807
 808 gdb_bfd_ref_ptr
 809 gdb_bfd_openr_iovec (const char *filename, const char *target,
 810                      void *(*open_func) (struct bfd *nbfd,
 811                                          void *open_closure),
 812                      void *open_closure,
 813                      file_ptr (*pread_func) (struct bfd *nbfd,
 814                                              void *stream,
 815                                              void *buf,
 816                                              file_ptr nbytes,
 817                                              file_ptr offset),
 818                      int (*close_func) (struct bfd *nbfd,
 819                                         void *stream),
 820                      int (*stat_func) (struct bfd *abfd,
 821                                        void *stream,
 822                                        struct stat *sb))
 823 {
 824   bfd *result = bfd_openr_iovec (filename, target,
 825                                  open_func, open_closure,
 826                                  pread_func, close_func, stat_func);
 827
 828   return gdb_bfd_ref_ptr::new_reference (result);
 829 }
 830
 831 /* See gdb_bfd.h.  */
 832
 833 void
 834 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 835 {
 836   struct gdb_bfd_data *gdata;
 837
 838   gdb_bfd_ref (child);
 839   /* No need to stash the filename here, because we also keep a
 840      reference on the parent archive.  */
 841
 842   gdata = (struct gdb_bfd_data *) bfd_usrdata (child);
 843   if (gdata->archive_bfd == NULL)
 844     {
 845       gdata->archive_bfd = parent;
 846       gdb_bfd_ref (parent);
 847     }
 848   else
 849     gdb_assert (gdata->archive_bfd == parent);
 850 }
 851
 852 /* See gdb_bfd.h.  */
 853
 854 gdb_bfd_ref_ptr
 855 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 856 {
 857   bfd *result = bfd_openr_next_archived_file (archive, previous);
 858
 859   if (result)
 860     gdb_bfd_mark_parent (result, archive);
 861
 862   return gdb_bfd_ref_ptr (result);
 863 }
 864
 865 /* See gdb_bfd.h.  */
 866
 867 void
 868 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 869 {
 870   struct gdb_bfd_data *gdata;
 871
 872   gdata = (struct gdb_bfd_data *) bfd_usrdata (includer);
 873   gdata->included_bfds.push_back (gdb_bfd_ref_ptr::new_reference (includee));
 874 }
 875
 876 \f
 877
 878 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 879
 880 /* See gdb_bfd.h.  */
 881
 882 int
 883 gdb_bfd_section_index (bfd *abfd, asection *section)
 884 {
 885   if (section == NULL)
 886     return -1;
 887   else if (section == bfd_com_section_ptr)
 888     return bfd_count_sections (abfd);
 889   else if (section == bfd_und_section_ptr)
 890     return bfd_count_sections (abfd) + 1;
 891   else if (section == bfd_abs_section_ptr)
 892     return bfd_count_sections (abfd) + 2;
 893   else if (section == bfd_ind_section_ptr)
 894     return bfd_count_sections (abfd) + 3;
 895   return section->index;
 896 }
 897
 898 /* See gdb_bfd.h.  */
 899
 900 int
 901 gdb_bfd_count_sections (bfd *abfd)
 902 {
 903   return bfd_count_sections (abfd) + 4;
 904 }
 905
 906 /* See gdb_bfd.h.  */
 907
 908 int
 909 gdb_bfd_requires_relocations (bfd *abfd)
 910 {
 911   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 912
 913   if (gdata->relocation_computed == 0)
 914     {
 915       asection *sect;
 916
 917       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 918         if ((sect->flags & SEC_RELOC) != 0)
 919           {
 920             gdata->needs_relocations = 1;
 921             break;
 922           }
 923
 924       gdata->relocation_computed = 1;
 925     }
 926
 927   return gdata->needs_relocations;
 928 }
 929
 930 \f
 931
 932 /* A callback for htab_traverse that prints a single BFD.  */
 933
 934 static int
 935 print_one_bfd (void **slot, void *data)
 936 {
 937   bfd *abfd = (struct bfd *) *slot;
 938   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 939   struct ui_out *uiout = (struct ui_out *) data;
 940
 941   ui_out_emit_tuple tuple_emitter (uiout, NULL);
 942   uiout->field_signed ("refcount", gdata->refc);
 943   uiout->field_string ("addr", host_address_to_string (abfd));
 944   uiout->field_string ("filename", bfd_get_filename (abfd));
 945   uiout->text ("\n");
 946
 947   return 1;
 948 }
 949
 950 /* Implement the 'maint info bfd' command.  */
 951
 952 static void
 953 maintenance_info_bfds (const char *arg, int from_tty)
 954 {
 955   struct ui_out *uiout = current_uiout;
 956
 957   ui_out_emit_table table_emitter (uiout, 3, -1, "bfds");
 958   uiout->table_header (10, ui_left, "refcount", "Refcount");
 959   uiout->table_header (18, ui_left, "addr", "Address");
 960   uiout->table_header (40, ui_left, "filename", "Filename");
 961
 962   uiout->table_body ();
 963   htab_traverse (all_bfds, print_one_bfd, uiout);
 964 }
 965
 966 void
 967 _initialize_gdb_bfd (void)
 968 {
 969   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
 970                                 NULL, xcalloc, xfree);
 971
 972   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
 973 List the BFDs that are currently open."),
 974            &maintenanceinfolist);
 975
 976   add_setshow_boolean_cmd ("bfd-sharing", no_class,
 977                            &bfd_sharing, _("\
 978 Set whether gdb will share bfds that appear to be the same file."), _("\
 979 Show whether gdb will share bfds that appear to be the same file."), _("\
 980 When enabled gdb will reuse existing bfds rather than reopening the\n\
 981 same file.  To decide if two files are the same then gdb compares the\n\
 982 filename, file size, file modification time, and file inode."),
 983                            NULL,
 984                            &show_bfd_sharing,
 985                            &maintenance_set_cmdlist,
 986                            &maintenance_show_cmdlist);
 987
 988   add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
 989                              &debug_bfd_cache, _("\
 990 Set bfd cache debugging."), _("\
 991 Show bfd cache debugging."), _("\
 992 When non-zero, bfd cache specific debugging is enabled."),
 993                              NULL,
 994                              &show_bfd_cache_debug,
 995                              &setdebuglist, &showdebuglist);
 996 }