gdb/gdb_bfd.c

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