gdb/gdb_bfd.c

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