gdb/gdb_bfd.c

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