gdb/gdb_bfd.c

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