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       gdb_bfd_ref (abfd);
 431       return gdb_bfd_ref_ptr (abfd);
 432     }
 433
 434   abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 435   if (abfd == NULL)
 436     return NULL;
 437
 438   if (debug_bfd_cache)
 439     fprintf_unfiltered (gdb_stdlog,
 440                         "Creating new bfd %s for %s\n",
 441                         host_address_to_string (abfd),
 442                         bfd_get_filename (abfd));
 443
 444   if (bfd_sharing)
 445     {
 446       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
 447       gdb_assert (!*slot);
 448       *slot = abfd;
 449     }
 450
 451   gdb_bfd_ref (abfd);
 452   return gdb_bfd_ref_ptr (abfd);
 453 }
 454
 455 /* A helper function that releases any section data attached to the
 456    BFD.  */
 457
 458 static void
 459 free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
 460 {
 461   struct gdb_bfd_section_data *sect
 462     = (struct gdb_bfd_section_data *) bfd_get_section_userdata (abfd, sectp);
 463
 464   if (sect != NULL && sect->data != NULL)
 465     {
 466 #ifdef HAVE_MMAP
 467       if (sect->map_addr != NULL)
 468         {
 469           int res;
 470
 471           res = munmap (sect->map_addr, sect->map_len);
 472           gdb_assert (res == 0);
 473         }
 474       else
 475 #endif
 476         xfree (sect->data);
 477     }
 478 }
 479
 480 /* Close ABFD, and warn if that fails.  */
 481
 482 static int
 483 gdb_bfd_close_or_warn (struct bfd *abfd)
 484 {
 485   int ret;
 486   char *name = bfd_get_filename (abfd);
 487
 488   bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
 489
 490   ret = bfd_close (abfd);
 491
 492   if (!ret)
 493     warning (_("cannot close \"%s\": %s"),
 494              name, bfd_errmsg (bfd_get_error ()));
 495
 496   return ret;
 497 }
 498
 499 /* See gdb_bfd.h.  */
 500
 501 void
 502 gdb_bfd_ref (struct bfd *abfd)
 503 {
 504   struct stat buf;
 505   struct gdb_bfd_data *gdata;
 506   void **slot;
 507
 508   if (abfd == NULL)
 509     return;
 510
 511   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 512
 513   if (debug_bfd_cache)
 514     fprintf_unfiltered (gdb_stdlog,
 515                         "Increase reference count on bfd %s (%s)\n",
 516                         host_address_to_string (abfd),
 517                         bfd_get_filename (abfd));
 518
 519   if (gdata != NULL)
 520     {
 521       gdata->refc += 1;
 522       return;
 523     }
 524
 525   /* Ask BFD to decompress sections in bfd_get_full_section_contents.  */
 526   abfd->flags |= BFD_DECOMPRESS;
 527
 528   gdata
 529     = (struct gdb_bfd_data *) bfd_zalloc (abfd, sizeof (struct gdb_bfd_data));
 530   gdata->refc = 1;
 531   gdata->mtime = bfd_get_mtime (abfd);
 532   gdata->size = bfd_get_size (abfd);
 533   gdata->archive_bfd = NULL;
 534   if (bfd_stat (abfd, &buf) == 0)
 535     {
 536       gdata->inode = buf.st_ino;
 537       gdata->device_id = buf.st_dev;
 538     }
 539   else
 540     {
 541       /* The stat failed.  */
 542       gdata->inode = 0;
 543       gdata->device_id = 0;
 544     }
 545   bfd_usrdata (abfd) = gdata;
 546
 547   bfd_alloc_data (abfd);
 548
 549   /* This is the first we've seen it, so add it to the hash table.  */
 550   slot = htab_find_slot (all_bfds, abfd, INSERT);
 551   gdb_assert (slot && !*slot);
 552   *slot = abfd;
 553 }
 554
 555 /* See gdb_bfd.h.  */
 556
 557 void
 558 gdb_bfd_unref (struct bfd *abfd)
 559 {
 560   int ix;
 561   struct gdb_bfd_data *gdata;
 562   struct gdb_bfd_cache_search search;
 563   bfd *archive_bfd, *included_bfd;
 564
 565   if (abfd == NULL)
 566     return;
 567
 568   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 569   gdb_assert (gdata->refc >= 1);
 570
 571   gdata->refc -= 1;
 572   if (gdata->refc > 0)
 573     {
 574       if (debug_bfd_cache)
 575         fprintf_unfiltered (gdb_stdlog,
 576                             "Decrease reference count on bfd %s (%s)\n",
 577                             host_address_to_string (abfd),
 578                             bfd_get_filename (abfd));
 579       return;
 580     }
 581
 582   if (debug_bfd_cache)
 583     fprintf_unfiltered (gdb_stdlog,
 584                         "Delete final reference count on bfd %s (%s)\n",
 585                         host_address_to_string (abfd),
 586                         bfd_get_filename (abfd));
 587
 588   archive_bfd = gdata->archive_bfd;
 589   search.filename = bfd_get_filename (abfd);
 590
 591   if (gdb_bfd_cache && search.filename)
 592     {
 593       hashval_t hash = htab_hash_string (search.filename);
 594       void **slot;
 595
 596       search.mtime = gdata->mtime;
 597       search.size = gdata->size;
 598       search.inode = gdata->inode;
 599       search.device_id = gdata->device_id;
 600       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 601                                        NO_INSERT);
 602
 603       if (slot && *slot)
 604         htab_clear_slot (gdb_bfd_cache, slot);
 605     }
 606
 607   for (ix = 0;
 608        VEC_iterate (bfdp, gdata->included_bfds, ix, included_bfd);
 609        ++ix)
 610     gdb_bfd_unref (included_bfd);
 611   VEC_free (bfdp, gdata->included_bfds);
 612
 613   bfd_free_data (abfd);
 614   bfd_usrdata (abfd) = NULL;  /* Paranoia.  */
 615
 616   htab_remove_elt (all_bfds, abfd);
 617
 618   gdb_bfd_close_or_warn (abfd);
 619
 620   gdb_bfd_unref (archive_bfd);
 621 }
 622
 623 /* A helper function that returns the section data descriptor
 624    associated with SECTION.  If no such descriptor exists, a new one
 625    is allocated and cleared.  */
 626
 627 static struct gdb_bfd_section_data *
 628 get_section_descriptor (asection *section)
 629 {
 630   struct gdb_bfd_section_data *result;
 631
 632   result = ((struct gdb_bfd_section_data *)
 633             bfd_get_section_userdata (section->owner, section));
 634
 635   if (result == NULL)
 636     {
 637       result = ((struct gdb_bfd_section_data *)
 638                 bfd_zalloc (section->owner, sizeof (*result)));
 639       bfd_set_section_userdata (section->owner, section, result);
 640     }
 641
 642   return result;
 643 }
 644
 645 /* See gdb_bfd.h.  */
 646
 647 const gdb_byte *
 648 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 649 {
 650   bfd *abfd;
 651   struct gdb_bfd_section_data *descriptor;
 652   bfd_byte *data;
 653
 654   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 655   gdb_assert (size != NULL);
 656
 657   abfd = sectp->owner;
 658
 659   descriptor = get_section_descriptor (sectp);
 660
 661   /* If the data was already read for this BFD, just reuse it.  */
 662   if (descriptor->data != NULL)
 663     goto done;
 664
 665 #ifdef HAVE_MMAP
 666   if (!bfd_is_section_compressed (abfd, sectp))
 667     {
 668       /* The page size, used when mmapping.  */
 669       static int pagesize;
 670
 671       if (pagesize == 0)
 672         pagesize = getpagesize ();
 673
 674       /* Only try to mmap sections which are large enough: we don't want
 675          to waste space due to fragmentation.  */
 676
 677       if (bfd_get_section_size (sectp) > 4 * pagesize)
 678         {
 679           descriptor->size = bfd_get_section_size (sectp);
 680           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 681                                        MAP_PRIVATE, sectp->filepos,
 682                                        &descriptor->map_addr,
 683                                        &descriptor->map_len);
 684
 685           if ((caddr_t)descriptor->data != MAP_FAILED)
 686             {
 687 #if HAVE_POSIX_MADVISE
 688               posix_madvise (descriptor->map_addr, descriptor->map_len,
 689                              POSIX_MADV_WILLNEED);
 690 #endif
 691               goto done;
 692             }
 693
 694           /* On failure, clear out the section data and try again.  */
 695           memset (descriptor, 0, sizeof (*descriptor));
 696         }
 697     }
 698 #endif /* HAVE_MMAP */
 699
 700   /* Handle compressed sections, or ordinary uncompressed sections in
 701      the no-mmap case.  */
 702
 703   descriptor->size = bfd_get_section_size (sectp);
 704   descriptor->data = NULL;
 705
 706   data = NULL;
 707   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 708     error (_("Can't read data for section '%s' in file '%s'"),
 709            bfd_get_section_name (abfd, sectp),
 710            bfd_get_filename (abfd));
 711   descriptor->data = data;
 712
 713  done:
 714   gdb_assert (descriptor->data != NULL);
 715   *size = descriptor->size;
 716   return (const gdb_byte *) descriptor->data;
 717 }
 718
 719 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 720    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 721    not preserved.  */
 722
 723 static int
 724 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 725 {
 726   unsigned long file_crc = 0;
 727
 728   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 729     {
 730       warning (_("Problem reading \"%s\" for CRC: %s"),
 731                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 732       return 0;
 733     }
 734
 735   for (;;)
 736     {
 737       gdb_byte buffer[8 * 1024];
 738       bfd_size_type count;
 739
 740       count = bfd_bread (buffer, sizeof (buffer), abfd);
 741       if (count == (bfd_size_type) -1)
 742         {
 743           warning (_("Problem reading \"%s\" for CRC: %s"),
 744                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 745           return 0;
 746         }
 747       if (count == 0)
 748         break;
 749       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 750     }
 751
 752   *file_crc_return = file_crc;
 753   return 1;
 754 }
 755
 756 /* See gdb_bfd.h.  */
 757
 758 int
 759 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 760 {
 761   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 762
 763   if (!gdata->crc_computed)
 764     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 765
 766   if (gdata->crc_computed)
 767     *crc_out = gdata->crc;
 768   return gdata->crc_computed;
 769 }
 770
 771 \f
 772
 773 /* See gdb_bfd.h.  */
 774
 775 gdb_bfd_ref_ptr
 776 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 777                int fd)
 778 {
 779   bfd *result = bfd_fopen (filename, target, mode, fd);
 780
 781   if (result)
 782     gdb_bfd_ref (result);
 783
 784   return gdb_bfd_ref_ptr (result);
 785 }
 786
 787 /* See gdb_bfd.h.  */
 788
 789 gdb_bfd_ref_ptr
 790 gdb_bfd_openr (const char *filename, const char *target)
 791 {
 792   bfd *result = bfd_openr (filename, target);
 793
 794   if (result)
 795     gdb_bfd_ref (result);
 796
 797   return gdb_bfd_ref_ptr (result);
 798 }
 799
 800 /* See gdb_bfd.h.  */
 801
 802 gdb_bfd_ref_ptr
 803 gdb_bfd_openw (const char *filename, const char *target)
 804 {
 805   bfd *result = bfd_openw (filename, target);
 806
 807   if (result)
 808     gdb_bfd_ref (result);
 809
 810   return gdb_bfd_ref_ptr (result);
 811 }
 812
 813 /* See gdb_bfd.h.  */
 814
 815 gdb_bfd_ref_ptr
 816 gdb_bfd_openr_iovec (const char *filename, const char *target,
 817                      void *(*open_func) (struct bfd *nbfd,
 818                                          void *open_closure),
 819                      void *open_closure,
 820                      file_ptr (*pread_func) (struct bfd *nbfd,
 821                                              void *stream,
 822                                              void *buf,
 823                                              file_ptr nbytes,
 824                                              file_ptr offset),
 825                      int (*close_func) (struct bfd *nbfd,
 826                                         void *stream),
 827                      int (*stat_func) (struct bfd *abfd,
 828                                        void *stream,
 829                                        struct stat *sb))
 830 {
 831   bfd *result = bfd_openr_iovec (filename, target,
 832                                  open_func, open_closure,
 833                                  pread_func, close_func, stat_func);
 834
 835   if (result)
 836     gdb_bfd_ref (result);
 837
 838   return gdb_bfd_ref_ptr (result);
 839 }
 840
 841 /* See gdb_bfd.h.  */
 842
 843 void
 844 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 845 {
 846   struct gdb_bfd_data *gdata;
 847
 848   gdb_bfd_ref (child);
 849   /* No need to stash the filename here, because we also keep a
 850      reference on the parent archive.  */
 851
 852   gdata = (struct gdb_bfd_data *) bfd_usrdata (child);
 853   if (gdata->archive_bfd == NULL)
 854     {
 855       gdata->archive_bfd = parent;
 856       gdb_bfd_ref (parent);
 857     }
 858   else
 859     gdb_assert (gdata->archive_bfd == parent);
 860 }
 861
 862 /* See gdb_bfd.h.  */
 863
 864 gdb_bfd_ref_ptr
 865 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 866 {
 867   bfd *result = bfd_openr_next_archived_file (archive, previous);
 868
 869   if (result)
 870     gdb_bfd_mark_parent (result, archive);
 871
 872   return gdb_bfd_ref_ptr (result);
 873 }
 874
 875 /* See gdb_bfd.h.  */
 876
 877 void
 878 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 879 {
 880   struct gdb_bfd_data *gdata;
 881
 882   gdb_bfd_ref (includee);
 883   gdata = (struct gdb_bfd_data *) bfd_usrdata (includer);
 884   VEC_safe_push (bfdp, gdata->included_bfds, includee);
 885 }
 886
 887 /* See gdb_bfd.h.  */
 888
 889 gdb_bfd_ref_ptr
 890 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
 891 {
 892   bfd *result = bfd_fdopenr (filename, target, fd);
 893
 894   if (result)
 895     gdb_bfd_ref (result);
 896
 897   return gdb_bfd_ref_ptr (result);
 898 }
 899
 900 \f
 901
 902 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 903
 904 /* See gdb_bfd.h.  */
 905
 906 int
 907 gdb_bfd_section_index (bfd *abfd, asection *section)
 908 {
 909   if (section == NULL)
 910     return -1;
 911   else if (section == bfd_com_section_ptr)
 912     return bfd_count_sections (abfd);
 913   else if (section == bfd_und_section_ptr)
 914     return bfd_count_sections (abfd) + 1;
 915   else if (section == bfd_abs_section_ptr)
 916     return bfd_count_sections (abfd) + 2;
 917   else if (section == bfd_ind_section_ptr)
 918     return bfd_count_sections (abfd) + 3;
 919   return section->index;
 920 }
 921
 922 /* See gdb_bfd.h.  */
 923
 924 int
 925 gdb_bfd_count_sections (bfd *abfd)
 926 {
 927   return bfd_count_sections (abfd) + 4;
 928 }
 929
 930 /* See gdb_bfd.h.  */
 931
 932 int
 933 gdb_bfd_requires_relocations (bfd *abfd)
 934 {
 935   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 936
 937   if (gdata->relocation_computed == 0)
 938     {
 939       asection *sect;
 940
 941       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 942         if ((sect->flags & SEC_RELOC) != 0)
 943           {
 944             gdata->needs_relocations = 1;
 945             break;
 946           }
 947
 948       gdata->relocation_computed = 1;
 949     }
 950
 951   return gdata->needs_relocations;
 952 }
 953
 954 \f
 955
 956 /* A callback for htab_traverse that prints a single BFD.  */
 957
 958 static int
 959 print_one_bfd (void **slot, void *data)
 960 {
 961   bfd *abfd = (struct bfd *) *slot;
 962   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 963   struct ui_out *uiout = (struct ui_out *) data;
 964
 965   ui_out_emit_tuple tuple_emitter (uiout, NULL);
 966   uiout->field_int ("refcount", gdata->refc);
 967   uiout->field_string ("addr", host_address_to_string (abfd));
 968   uiout->field_string ("filename", bfd_get_filename (abfd));
 969   uiout->text ("\n");
 970
 971   return 1;
 972 }
 973
 974 /* Implement the 'maint info bfd' command.  */
 975
 976 static void
 977 maintenance_info_bfds (char *arg, int from_tty)
 978 {
 979   struct ui_out *uiout = current_uiout;
 980
 981   ui_out_emit_table table_emitter (uiout, 3, -1, "bfds");
 982   uiout->table_header (10, ui_left, "refcount", "Refcount");
 983   uiout->table_header (18, ui_left, "addr", "Address");
 984   uiout->table_header (40, ui_left, "filename", "Filename");
 985
 986   uiout->table_body ();
 987   htab_traverse (all_bfds, print_one_bfd, uiout);
 988 }
 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 }