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