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 ((struct inferior *) inferior,
 265                            filename + strlen (TARGET_SYSROOT_PREFIX),
 266                            FILEIO_O_RDONLY, 0,
 267                            &target_errno);
 268   if (fd == -1)
 269     {
 270       errno = fileio_errno_to_host (target_errno);
 271       bfd_set_error (bfd_error_system_call);
 272       return NULL;
 273     }
 274
 275   stream = XCNEW (int);
 276   *stream = fd;
 277   return stream;
 278 }
 279
 280 /* Wrapper for target_fileio_pread suitable for passing as the
 281    PREAD_FUNC argument to gdb_bfd_openr_iovec.  */
 282
 283 static file_ptr
 284 gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf,
 285                             file_ptr nbytes, file_ptr offset)
 286 {
 287   int fd = *(int *) stream;
 288   int target_errno;
 289   file_ptr pos, bytes;
 290
 291   pos = 0;
 292   while (nbytes > pos)
 293     {
 294       bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos,
 295                                    nbytes - pos, offset + pos,
 296                                    &target_errno);
 297       if (bytes == 0)
 298         /* Success, but no bytes, means end-of-file.  */
 299         break;
 300       if (bytes == -1)
 301         {
 302           errno = fileio_errno_to_host (target_errno);
 303           bfd_set_error (bfd_error_system_call);
 304           return -1;
 305         }
 306
 307       pos += bytes;
 308     }
 309
 310   return pos;
 311 }
 312
 313 /* Wrapper for target_fileio_close suitable for passing as the
 314    CLOSE_FUNC argument to gdb_bfd_openr_iovec.  */
 315
 316 static int
 317 gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream)
 318 {
 319   int fd = *(int *) stream;
 320   int target_errno;
 321
 322   xfree (stream);
 323
 324   /* Ignore errors on close.  These may happen with remote
 325      targets if the connection has already been torn down.  */
 326   target_fileio_close (fd, &target_errno);
 327
 328   /* Zero means success.  */
 329   return 0;
 330 }
 331
 332 /* Wrapper for target_fileio_fstat suitable for passing as the
 333    STAT_FUNC argument to gdb_bfd_openr_iovec.  */
 334
 335 static int
 336 gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream,
 337                             struct stat *sb)
 338 {
 339   int fd = *(int *) stream;
 340   int target_errno;
 341   int result;
 342
 343   result = target_fileio_fstat (fd, sb, &target_errno);
 344   if (result == -1)
 345     {
 346       errno = fileio_errno_to_host (target_errno);
 347       bfd_set_error (bfd_error_system_call);
 348     }
 349
 350   return result;
 351 }
 352
 353 /* See gdb_bfd.h.  */
 354
 355 struct bfd *
 356 gdb_bfd_open (const char *name, const char *target, int fd)
 357 {
 358   hashval_t hash;
 359   void **slot;
 360   bfd *abfd;
 361   struct gdb_bfd_cache_search search;
 362   struct stat st;
 363
 364   if (is_target_filename (name))
 365     {
 366       if (!target_filesystem_is_local ())
 367         {
 368           gdb_assert (fd == -1);
 369
 370           return gdb_bfd_openr_iovec (name, target,
 371                                       gdb_bfd_iovec_fileio_open,
 372                                       current_inferior (),
 373                                       gdb_bfd_iovec_fileio_pread,
 374                                       gdb_bfd_iovec_fileio_close,
 375                                       gdb_bfd_iovec_fileio_fstat);
 376         }
 377
 378       name += strlen (TARGET_SYSROOT_PREFIX);
 379     }
 380
 381   if (gdb_bfd_cache == NULL)
 382     gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
 383                                        xcalloc, xfree);
 384
 385   if (fd == -1)
 386     {
 387       fd = gdb_open_cloexec (name, O_RDONLY | O_BINARY, 0);
 388       if (fd == -1)
 389         {
 390           bfd_set_error (bfd_error_system_call);
 391           return NULL;
 392         }
 393     }
 394
 395   search.filename = name;
 396   if (fstat (fd, &st) < 0)
 397     {
 398       /* Weird situation here.  */
 399       search.mtime = 0;
 400       search.size = 0;
 401       search.inode = 0;
 402       search.device_id = 0;
 403     }
 404   else
 405     {
 406       search.mtime = st.st_mtime;
 407       search.size = st.st_size;
 408       search.inode = st.st_ino;
 409       search.device_id = st.st_dev;
 410     }
 411
 412   /* Note that this must compute the same result as hash_bfd.  */
 413   hash = htab_hash_string (name);
 414   /* Note that we cannot use htab_find_slot_with_hash here, because
 415      opening the BFD may fail; and this would violate hashtab
 416      invariants.  */
 417   abfd = htab_find_with_hash (gdb_bfd_cache, &search, hash);
 418   if (bfd_sharing && abfd != NULL)
 419     {
 420       if (debug_bfd_cache)
 421         fprintf_unfiltered (gdb_stdlog,
 422                             "Reusing cached bfd %s for %s\n",
 423                             host_address_to_string (abfd),
 424                             bfd_get_filename (abfd));
 425       close (fd);
 426       gdb_bfd_ref (abfd);
 427       return abfd;
 428     }
 429
 430   abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 431   if (abfd == NULL)
 432     return NULL;
 433
 434   if (debug_bfd_cache)
 435     fprintf_unfiltered (gdb_stdlog,
 436                         "Creating new bfd %s for %s\n",
 437                         host_address_to_string (abfd),
 438                         bfd_get_filename (abfd));
 439
 440   if (bfd_sharing)
 441     {
 442       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
 443       gdb_assert (!*slot);
 444       *slot = abfd;
 445     }
 446
 447   gdb_bfd_ref (abfd);
 448   return abfd;
 449 }
 450
 451 /* A helper function that releases any section data attached to the
 452    BFD.  */
 453
 454 static void
 455 free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
 456 {
 457   struct gdb_bfd_section_data *sect = bfd_get_section_userdata (abfd, sectp);
 458
 459   if (sect != NULL && sect->data != NULL)
 460     {
 461 #ifdef HAVE_MMAP
 462       if (sect->map_addr != NULL)
 463         {
 464           int res;
 465
 466           res = munmap (sect->map_addr, sect->map_len);
 467           gdb_assert (res == 0);
 468         }
 469       else
 470 #endif
 471         xfree (sect->data);
 472     }
 473 }
 474
 475 /* Close ABFD, and warn if that fails.  */
 476
 477 static int
 478 gdb_bfd_close_or_warn (struct bfd *abfd)
 479 {
 480   int ret;
 481   char *name = bfd_get_filename (abfd);
 482
 483   bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
 484
 485   ret = bfd_close (abfd);
 486
 487   if (!ret)
 488     warning (_("cannot close \"%s\": %s"),
 489              name, bfd_errmsg (bfd_get_error ()));
 490
 491   return ret;
 492 }
 493
 494 /* See gdb_bfd.h.  */
 495
 496 void
 497 gdb_bfd_ref (struct bfd *abfd)
 498 {
 499   struct stat buf;
 500   struct gdb_bfd_data *gdata;
 501   void **slot;
 502
 503   if (abfd == NULL)
 504     return;
 505
 506   gdata = bfd_usrdata (abfd);
 507
 508   if (debug_bfd_cache)
 509     fprintf_unfiltered (gdb_stdlog,
 510                         "Increase reference count on bfd %s (%s)\n",
 511                         host_address_to_string (abfd),
 512                         bfd_get_filename (abfd));
 513
 514   if (gdata != NULL)
 515     {
 516       gdata->refc += 1;
 517       return;
 518     }
 519
 520   /* Ask BFD to decompress sections in bfd_get_full_section_contents.  */
 521   abfd->flags |= BFD_DECOMPRESS;
 522
 523   gdata = bfd_zalloc (abfd, sizeof (struct gdb_bfd_data));
 524   gdata->refc = 1;
 525   gdata->mtime = bfd_get_mtime (abfd);
 526   gdata->size = bfd_get_size (abfd);
 527   gdata->archive_bfd = NULL;
 528   if (bfd_stat (abfd, &buf) == 0)
 529     {
 530       gdata->inode = buf.st_ino;
 531       gdata->device_id = buf.st_dev;
 532     }
 533   else
 534     {
 535       /* The stat failed.  */
 536       gdata->inode = 0;
 537       gdata->device_id = 0;
 538     }
 539   bfd_usrdata (abfd) = gdata;
 540
 541   bfd_alloc_data (abfd);
 542
 543   /* This is the first we've seen it, so add it to the hash table.  */
 544   slot = htab_find_slot (all_bfds, abfd, INSERT);
 545   gdb_assert (slot && !*slot);
 546   *slot = abfd;
 547 }
 548
 549 /* See gdb_bfd.h.  */
 550
 551 void
 552 gdb_bfd_unref (struct bfd *abfd)
 553 {
 554   int ix;
 555   struct gdb_bfd_data *gdata;
 556   struct gdb_bfd_cache_search search;
 557   bfd *archive_bfd, *included_bfd;
 558
 559   if (abfd == NULL)
 560     return;
 561
 562   gdata = bfd_usrdata (abfd);
 563   gdb_assert (gdata->refc >= 1);
 564
 565   gdata->refc -= 1;
 566   if (gdata->refc > 0)
 567     {
 568       if (debug_bfd_cache)
 569         fprintf_unfiltered (gdb_stdlog,
 570                             "Decrease reference count on bfd %s (%s)\n",
 571                             host_address_to_string (abfd),
 572                             bfd_get_filename (abfd));
 573       return;
 574     }
 575
 576   if (debug_bfd_cache)
 577     fprintf_unfiltered (gdb_stdlog,
 578                         "Delete final reference count on bfd %s (%s)\n",
 579                         host_address_to_string (abfd),
 580                         bfd_get_filename (abfd));
 581
 582   archive_bfd = gdata->archive_bfd;
 583   search.filename = bfd_get_filename (abfd);
 584
 585   if (gdb_bfd_cache && search.filename)
 586     {
 587       hashval_t hash = htab_hash_string (search.filename);
 588       void **slot;
 589
 590       search.mtime = gdata->mtime;
 591       search.size = gdata->size;
 592       search.inode = gdata->inode;
 593       search.device_id = gdata->device_id;
 594       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 595                                        NO_INSERT);
 596
 597       if (slot && *slot)
 598         htab_clear_slot (gdb_bfd_cache, slot);
 599     }
 600
 601   for (ix = 0;
 602        VEC_iterate (bfdp, gdata->included_bfds, ix, included_bfd);
 603        ++ix)
 604     gdb_bfd_unref (included_bfd);
 605   VEC_free (bfdp, gdata->included_bfds);
 606
 607   bfd_free_data (abfd);
 608   bfd_usrdata (abfd) = NULL;  /* Paranoia.  */
 609
 610   htab_remove_elt (all_bfds, abfd);
 611
 612   gdb_bfd_close_or_warn (abfd);
 613
 614   gdb_bfd_unref (archive_bfd);
 615 }
 616
 617 /* A helper function that returns the section data descriptor
 618    associated with SECTION.  If no such descriptor exists, a new one
 619    is allocated and cleared.  */
 620
 621 static struct gdb_bfd_section_data *
 622 get_section_descriptor (asection *section)
 623 {
 624   struct gdb_bfd_section_data *result;
 625
 626   result = bfd_get_section_userdata (section->owner, section);
 627
 628   if (result == NULL)
 629     {
 630       result = bfd_zalloc (section->owner, sizeof (*result));
 631       bfd_set_section_userdata (section->owner, section, result);
 632     }
 633
 634   return result;
 635 }
 636
 637 /* See gdb_bfd.h.  */
 638
 639 const gdb_byte *
 640 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 641 {
 642   bfd *abfd;
 643   struct gdb_bfd_section_data *descriptor;
 644   bfd_byte *data;
 645
 646   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 647   gdb_assert (size != NULL);
 648
 649   abfd = sectp->owner;
 650
 651   descriptor = get_section_descriptor (sectp);
 652
 653   /* If the data was already read for this BFD, just reuse it.  */
 654   if (descriptor->data != NULL)
 655     goto done;
 656
 657 #ifdef HAVE_MMAP
 658   if (!bfd_is_section_compressed (abfd, sectp))
 659     {
 660       /* The page size, used when mmapping.  */
 661       static int pagesize;
 662
 663       if (pagesize == 0)
 664         pagesize = getpagesize ();
 665
 666       /* Only try to mmap sections which are large enough: we don't want
 667          to waste space due to fragmentation.  */
 668
 669       if (bfd_get_section_size (sectp) > 4 * pagesize)
 670         {
 671           descriptor->size = bfd_get_section_size (sectp);
 672           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 673                                        MAP_PRIVATE, sectp->filepos,
 674                                        &descriptor->map_addr,
 675                                        &descriptor->map_len);
 676
 677           if ((caddr_t)descriptor->data != MAP_FAILED)
 678             {
 679 #if HAVE_POSIX_MADVISE
 680               posix_madvise (descriptor->map_addr, descriptor->map_len,
 681                              POSIX_MADV_WILLNEED);
 682 #endif
 683               goto done;
 684             }
 685
 686           /* On failure, clear out the section data and try again.  */
 687           memset (descriptor, 0, sizeof (*descriptor));
 688         }
 689     }
 690 #endif /* HAVE_MMAP */
 691
 692   /* Handle compressed sections, or ordinary uncompressed sections in
 693      the no-mmap case.  */
 694
 695   descriptor->size = bfd_get_section_size (sectp);
 696   descriptor->data = NULL;
 697
 698   data = NULL;
 699   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 700     error (_("Can't read data for section '%s' in file '%s'"),
 701            bfd_get_section_name (abfd, sectp),
 702            bfd_get_filename (abfd));
 703   descriptor->data = data;
 704
 705  done:
 706   gdb_assert (descriptor->data != NULL);
 707   *size = descriptor->size;
 708   return descriptor->data;
 709 }
 710
 711 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 712    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 713    not preserved.  */
 714
 715 static int
 716 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 717 {
 718   unsigned long file_crc = 0;
 719
 720   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 721     {
 722       warning (_("Problem reading \"%s\" for CRC: %s"),
 723                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 724       return 0;
 725     }
 726
 727   for (;;)
 728     {
 729       gdb_byte buffer[8 * 1024];
 730       bfd_size_type count;
 731
 732       count = bfd_bread (buffer, sizeof (buffer), abfd);
 733       if (count == (bfd_size_type) -1)
 734         {
 735           warning (_("Problem reading \"%s\" for CRC: %s"),
 736                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 737           return 0;
 738         }
 739       if (count == 0)
 740         break;
 741       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 742     }
 743
 744   *file_crc_return = file_crc;
 745   return 1;
 746 }
 747
 748 /* See gdb_bfd.h.  */
 749
 750 int
 751 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 752 {
 753   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 754
 755   if (!gdata->crc_computed)
 756     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 757
 758   if (gdata->crc_computed)
 759     *crc_out = gdata->crc;
 760   return gdata->crc_computed;
 761 }
 762
 763 \f
 764
 765 /* See gdb_bfd.h.  */
 766
 767 bfd *
 768 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 769                int fd)
 770 {
 771   bfd *result = bfd_fopen (filename, target, mode, fd);
 772
 773   if (result)
 774     gdb_bfd_ref (result);
 775
 776   return result;
 777 }
 778
 779 /* See gdb_bfd.h.  */
 780
 781 bfd *
 782 gdb_bfd_openr (const char *filename, const char *target)
 783 {
 784   bfd *result = bfd_openr (filename, target);
 785
 786   if (result)
 787     gdb_bfd_ref (result);
 788
 789   return result;
 790 }
 791
 792 /* See gdb_bfd.h.  */
 793
 794 bfd *
 795 gdb_bfd_openw (const char *filename, const char *target)
 796 {
 797   bfd *result = bfd_openw (filename, target);
 798
 799   if (result)
 800     gdb_bfd_ref (result);
 801
 802   return result;
 803 }
 804
 805 /* See gdb_bfd.h.  */
 806
 807 bfd *
 808 gdb_bfd_openr_iovec (const char *filename, const char *target,
 809                      void *(*open_func) (struct bfd *nbfd,
 810                                          void *open_closure),
 811                      void *open_closure,
 812                      file_ptr (*pread_func) (struct bfd *nbfd,
 813                                              void *stream,
 814                                              void *buf,
 815                                              file_ptr nbytes,
 816                                              file_ptr offset),
 817                      int (*close_func) (struct bfd *nbfd,
 818                                         void *stream),
 819                      int (*stat_func) (struct bfd *abfd,
 820                                        void *stream,
 821                                        struct stat *sb))
 822 {
 823   bfd *result = bfd_openr_iovec (filename, target,
 824                                  open_func, open_closure,
 825                                  pread_func, close_func, stat_func);
 826
 827   if (result)
 828     gdb_bfd_ref (result);
 829
 830   return result;
 831 }
 832
 833 /* See gdb_bfd.h.  */
 834
 835 void
 836 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 837 {
 838   struct gdb_bfd_data *gdata;
 839
 840   gdb_bfd_ref (child);
 841   /* No need to stash the filename here, because we also keep a
 842      reference on the parent archive.  */
 843
 844   gdata = bfd_usrdata (child);
 845   if (gdata->archive_bfd == NULL)
 846     {
 847       gdata->archive_bfd = parent;
 848       gdb_bfd_ref (parent);
 849     }
 850   else
 851     gdb_assert (gdata->archive_bfd == parent);
 852 }
 853
 854 /* See gdb_bfd.h.  */
 855
 856 bfd *
 857 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 858 {
 859   bfd *result = bfd_openr_next_archived_file (archive, previous);
 860
 861   if (result)
 862     gdb_bfd_mark_parent (result, archive);
 863
 864   return result;
 865 }
 866
 867 /* See gdb_bfd.h.  */
 868
 869 void
 870 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 871 {
 872   struct gdb_bfd_data *gdata;
 873
 874   gdb_bfd_ref (includee);
 875   gdata = bfd_usrdata (includer);
 876   VEC_safe_push (bfdp, gdata->included_bfds, includee);
 877 }
 878
 879 /* See gdb_bfd.h.  */
 880
 881 bfd *
 882 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
 883 {
 884   bfd *result = bfd_fdopenr (filename, target, fd);
 885
 886   if (result)
 887     gdb_bfd_ref (result);
 888
 889   return result;
 890 }
 891
 892 \f
 893
 894 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 895
 896 /* See gdb_bfd.h.  */
 897
 898 int
 899 gdb_bfd_section_index (bfd *abfd, asection *section)
 900 {
 901   if (section == NULL)
 902     return -1;
 903   else if (section == bfd_com_section_ptr)
 904     return bfd_count_sections (abfd);
 905   else if (section == bfd_und_section_ptr)
 906     return bfd_count_sections (abfd) + 1;
 907   else if (section == bfd_abs_section_ptr)
 908     return bfd_count_sections (abfd) + 2;
 909   else if (section == bfd_ind_section_ptr)
 910     return bfd_count_sections (abfd) + 3;
 911   return section->index;
 912 }
 913
 914 /* See gdb_bfd.h.  */
 915
 916 int
 917 gdb_bfd_count_sections (bfd *abfd)
 918 {
 919   return bfd_count_sections (abfd) + 4;
 920 }
 921
 922 /* See gdb_bfd.h.  */
 923
 924 int
 925 gdb_bfd_requires_relocations (bfd *abfd)
 926 {
 927   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 928
 929   if (gdata->relocation_computed == 0)
 930     {
 931       asection *sect;
 932
 933       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 934         if ((sect->flags & SEC_RELOC) != 0)
 935           {
 936             gdata->needs_relocations = 1;
 937             break;
 938           }
 939
 940       gdata->relocation_computed = 1;
 941     }
 942
 943   return gdata->needs_relocations;
 944 }
 945
 946 \f
 947
 948 /* A callback for htab_traverse that prints a single BFD.  */
 949
 950 static int
 951 print_one_bfd (void **slot, void *data)
 952 {
 953   bfd *abfd = *slot;
 954   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 955   struct ui_out *uiout = data;
 956   struct cleanup *inner;
 957
 958   inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 959   ui_out_field_int (uiout, "refcount", gdata->refc);
 960   ui_out_field_string (uiout, "addr", host_address_to_string (abfd));
 961   ui_out_field_string (uiout, "filename", bfd_get_filename (abfd));
 962   ui_out_text (uiout, "\n");
 963   do_cleanups (inner);
 964
 965   return 1;
 966 }
 967
 968 /* Implement the 'maint info bfd' command.  */
 969
 970 static void
 971 maintenance_info_bfds (char *arg, int from_tty)
 972 {
 973   struct cleanup *cleanup;
 974   struct ui_out *uiout = current_uiout;
 975
 976   cleanup = make_cleanup_ui_out_table_begin_end (uiout, 3, -1, "bfds");
 977   ui_out_table_header (uiout, 10, ui_left, "refcount", "Refcount");
 978   ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
 979   ui_out_table_header (uiout, 40, ui_left, "filename", "Filename");
 980
 981   ui_out_table_body (uiout);
 982   htab_traverse (all_bfds, print_one_bfd, uiout);
 983
 984   do_cleanups (cleanup);
 985 }
 986
 987 /* -Wmissing-prototypes */
 988 extern initialize_file_ftype _initialize_gdb_bfd;
 989
 990 void
 991 _initialize_gdb_bfd (void)
 992 {
 993   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
 994                                 NULL, xcalloc, xfree);
 995
 996   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
 997 List the BFDs that are currently open."),
 998            &maintenanceinfolist);
 999
1000   add_setshow_boolean_cmd ("bfd-sharing", no_class,
1001                            &bfd_sharing, _("\
1002 Set whether gdb will share bfds that appear to be the same file."), _("\
1003 Show whether gdb will share bfds that appear to be the same file."), _("\
1004 When enabled gdb will reuse existing bfds rather than reopening the\n\
1005 same file.  To decide if two files are the same then gdb compares the\n\
1006 filename, file size, file modification time, and file inode."),
1007                            NULL,
1008                            &show_bfd_sharing,
1009                            &maintenance_set_cmdlist,
1010                            &maintenance_show_cmdlist);
1011
1012   add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
1013                              &debug_bfd_cache, _("\
1014 Set bfd cache debugging."), _("\
1015 Show bfd cache debugging."), _("\
1016 When non-zero, bfd cache specific debugging is enabled."),
1017                              NULL,
1018                              &show_bfd_cache_debug,
1019                              &setdebuglist, &showdebuglist);
1020 }