gdb/gdb_bfd.c

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