gdb/gdb_bfd.c

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