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<bfd> registry_fields;
 116 };
 117
 118 registry<bfd> *
 119 registry_accessor<bfd>::get (bfd *abfd)
 120 {
 121   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 122   return &gdata->registry_fields;
 123 }
 124
 125 /* A hash table storing all the BFDs maintained in the cache.  */
 126
 127 static htab_t gdb_bfd_cache;
 128
 129 /* When true gdb will reuse an existing bfd object if the filename,
 130    modification time, and file size all match.  */
 131
 132 static bool bfd_sharing = true;
 133 static void
 134 show_bfd_sharing  (struct ui_file *file, int from_tty,
 135                    struct cmd_list_element *c, const char *value)
 136 {
 137   gdb_printf (file, _("BFD sharing is %s.\n"), value);
 138 }
 139
 140 /* When true debugging of the bfd caches is enabled.  */
 141
 142 static bool debug_bfd_cache;
 143
 144 /* Print an "bfd-cache" debug statement.  */
 145
 146 #define bfd_cache_debug_printf(fmt, ...) \
 147   debug_prefixed_printf_cond (debug_bfd_cache, "bfd-cache", fmt, ##__VA_ARGS__)
 148
 149 static void
 150 show_bfd_cache_debug (struct ui_file *file, int from_tty,
 151                       struct cmd_list_element *c, const char *value)
 152 {
 153   gdb_printf (file, _("BFD cache debugging is %s.\n"), value);
 154 }
 155
 156 /* The type of an object being looked up in gdb_bfd_cache.  We use
 157    htab's capability of storing one kind of object (BFD in this case)
 158    and using a different sort of object for searching.  */
 159
 160 struct gdb_bfd_cache_search
 161 {
 162   /* The filename.  */
 163   const char *filename;
 164   /* The mtime.  */
 165   time_t mtime;
 166   /* The file size (in bytes).  */
 167   off_t size;
 168   /* The inode of the file.  */
 169   ino_t inode;
 170   /* The device id of the file.  */
 171   dev_t device_id;
 172 };
 173
 174 /* A hash function for BFDs.  */
 175
 176 static hashval_t
 177 hash_bfd (const void *b)
 178 {
 179   const bfd *abfd = (const struct bfd *) b;
 180
 181   /* It is simplest to just hash the filename.  */
 182   return htab_hash_string (bfd_get_filename (abfd));
 183 }
 184
 185 /* An equality function for BFDs.  Note that this expects the caller
 186    to search using struct gdb_bfd_cache_search only, not BFDs.  */
 187
 188 static int
 189 eq_bfd (const void *a, const void *b)
 190 {
 191   const bfd *abfd = (const struct bfd *) a;
 192   const struct gdb_bfd_cache_search *s
 193     = (const struct gdb_bfd_cache_search *) b;
 194   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 195
 196   return (gdata->mtime == s->mtime
 197           && gdata->size == s->size
 198           && gdata->inode == s->inode
 199           && gdata->device_id == s->device_id
 200           && strcmp (bfd_get_filename (abfd), s->filename) == 0);
 201 }
 202
 203 /* See gdb_bfd.h.  */
 204
 205 int
 206 is_target_filename (const char *name)
 207 {
 208   return startswith (name, TARGET_SYSROOT_PREFIX);
 209 }
 210
 211 /* See gdb_bfd.h.  */
 212
 213 int
 214 gdb_bfd_has_target_filename (struct bfd *abfd)
 215 {
 216   return is_target_filename (bfd_get_filename (abfd));
 217 }
 218
 219 /* For `gdb_bfd_open_from_target_memory`.  */
 220
 221 struct target_buffer
 222 {
 223   CORE_ADDR base;
 224   ULONGEST size;
 225 };
 226
 227 /* For `gdb_bfd_open_from_target_memory`.  Opening the file is a no-op.  */
 228
 229 static void *
 230 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
 231 {
 232   return open_closure;
 233 }
 234
 235 /* For `gdb_bfd_open_from_target_memory`.  Closing the file is just freeing the
 236    base/size pair on our side.  */
 237
 238 static int
 239 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
 240 {
 241   xfree (stream);
 242
 243   /* Zero means success.  */
 244   return 0;
 245 }
 246
 247 /* For `gdb_bfd_open_from_target_memory`.  For reading the file, we just need to
 248    pass through to target_read_memory and fix up the arguments and return
 249    values.  */
 250
 251 static file_ptr
 252 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
 253                      file_ptr nbytes, file_ptr offset)
 254 {
 255   int err;
 256   struct target_buffer *buffer = (struct target_buffer *) stream;
 257
 258   /* If this read will read all of the file, limit it to just the rest.  */
 259   if (offset + nbytes > buffer->size)
 260     nbytes = buffer->size - offset;
 261
 262   /* If there are no more bytes left, we've reached EOF.  */
 263   if (nbytes == 0)
 264     return 0;
 265
 266   err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
 267   if (err)
 268     return -1;
 269
 270   return nbytes;
 271 }
 272
 273 /* For `gdb_bfd_open_from_target_memory`.  For statting the file, we only
 274    support the st_size attribute.  */
 275
 276 static int
 277 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 278 {
 279   struct target_buffer *buffer = (struct target_buffer*) stream;
 280
 281   memset (sb, 0, sizeof (struct stat));
 282   sb->st_size = buffer->size;
 283   return 0;
 284 }
 285
 286 /* See gdb_bfd.h.  */
 287
 288 gdb_bfd_ref_ptr
 289 gdb_bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size,
 290                                  const char *target,
 291                                  const char *filename)
 292 {
 293   struct target_buffer *buffer = XNEW (struct target_buffer);
 294
 295   buffer->base = addr;
 296   buffer->size = size;
 297   return gdb_bfd_openr_iovec (filename ? filename : "<in-memory>", target,
 298                               mem_bfd_iovec_open,
 299                               buffer,
 300                               mem_bfd_iovec_pread,
 301                               mem_bfd_iovec_close,
 302                               mem_bfd_iovec_stat);
 303 }
 304
 305 /* Return the system error number corresponding to ERRNUM.  */
 306
 307 static int
 308 fileio_errno_to_host (int errnum)
 309 {
 310   switch (errnum)
 311     {
 312       case FILEIO_EPERM:
 313         return EPERM;
 314       case FILEIO_ENOENT:
 315         return ENOENT;
 316       case FILEIO_EINTR:
 317         return EINTR;
 318       case FILEIO_EIO:
 319         return EIO;
 320       case FILEIO_EBADF:
 321         return EBADF;
 322       case FILEIO_EACCES:
 323         return EACCES;
 324       case FILEIO_EFAULT:
 325         return EFAULT;
 326       case FILEIO_EBUSY:
 327         return EBUSY;
 328       case FILEIO_EEXIST:
 329         return EEXIST;
 330       case FILEIO_ENODEV:
 331         return ENODEV;
 332       case FILEIO_ENOTDIR:
 333         return ENOTDIR;
 334       case FILEIO_EISDIR:
 335         return EISDIR;
 336       case FILEIO_EINVAL:
 337         return EINVAL;
 338       case FILEIO_ENFILE:
 339         return ENFILE;
 340       case FILEIO_EMFILE:
 341         return EMFILE;
 342       case FILEIO_EFBIG:
 343         return EFBIG;
 344       case FILEIO_ENOSPC:
 345         return ENOSPC;
 346       case FILEIO_ESPIPE:
 347         return ESPIPE;
 348       case FILEIO_EROFS:
 349         return EROFS;
 350       case FILEIO_ENOSYS:
 351         return ENOSYS;
 352       case FILEIO_ENAMETOOLONG:
 353         return ENAMETOOLONG;
 354     }
 355   return -1;
 356 }
 357
 358 /* bfd_openr_iovec OPEN_CLOSURE data for gdb_bfd_open.  */
 359 struct gdb_bfd_open_closure
 360 {
 361   inferior *inf;
 362   bool warn_if_slow;
 363 };
 364
 365 /* Wrapper for target_fileio_open suitable for passing as the
 366    OPEN_FUNC argument to gdb_bfd_openr_iovec.  */
 367
 368 static void *
 369 gdb_bfd_iovec_fileio_open (struct bfd *abfd, void *open_closure)
 370 {
 371   const char *filename = bfd_get_filename (abfd);
 372   int fd, target_errno;
 373   int *stream;
 374   gdb_bfd_open_closure *oclosure = (gdb_bfd_open_closure *) open_closure;
 375
 376   gdb_assert (is_target_filename (filename));
 377
 378   fd = target_fileio_open (oclosure->inf,
 379                            filename + strlen (TARGET_SYSROOT_PREFIX),
 380                            FILEIO_O_RDONLY, 0, oclosure->warn_if_slow,
 381                            &target_errno);
 382   if (fd == -1)
 383     {
 384       errno = fileio_errno_to_host (target_errno);
 385       bfd_set_error (bfd_error_system_call);
 386       return NULL;
 387     }
 388
 389   stream = XCNEW (int);
 390   *stream = fd;
 391   return stream;
 392 }
 393
 394 /* Wrapper for target_fileio_pread suitable for passing as the
 395    PREAD_FUNC argument to gdb_bfd_openr_iovec.  */
 396
 397 static file_ptr
 398 gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf,
 399                             file_ptr nbytes, file_ptr offset)
 400 {
 401   int fd = *(int *) stream;
 402   int target_errno;
 403   file_ptr pos, bytes;
 404
 405   pos = 0;
 406   while (nbytes > pos)
 407     {
 408       QUIT;
 409
 410       bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos,
 411                                    nbytes - pos, offset + pos,
 412                                    &target_errno);
 413       if (bytes == 0)
 414         /* Success, but no bytes, means end-of-file.  */
 415         break;
 416       if (bytes == -1)
 417         {
 418           errno = fileio_errno_to_host (target_errno);
 419           bfd_set_error (bfd_error_system_call);
 420           return -1;
 421         }
 422
 423       pos += bytes;
 424     }
 425
 426   return pos;
 427 }
 428
 429 /* Warn that it wasn't possible to close a bfd for file NAME, because
 430    of REASON.  */
 431
 432 static void
 433 gdb_bfd_close_warning (const char *name, const char *reason)
 434 {
 435   warning (_("cannot close \"%s\": %s"), name, reason);
 436 }
 437
 438 /* Wrapper for target_fileio_close suitable for passing as the
 439    CLOSE_FUNC argument to gdb_bfd_openr_iovec.  */
 440
 441 static int
 442 gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream)
 443 {
 444   int fd = *(int *) stream;
 445   int target_errno;
 446
 447   xfree (stream);
 448
 449   /* Ignore errors on close.  These may happen with remote
 450      targets if the connection has already been torn down.  */
 451   try
 452     {
 453       target_fileio_close (fd, &target_errno);
 454     }
 455   catch (const gdb_exception &ex)
 456     {
 457       /* Also avoid crossing exceptions over bfd.  */
 458       gdb_bfd_close_warning (bfd_get_filename (abfd),
 459                              ex.message->c_str ());
 460     }
 461
 462   /* Zero means success.  */
 463   return 0;
 464 }
 465
 466 /* Wrapper for target_fileio_fstat suitable for passing as the
 467    STAT_FUNC argument to gdb_bfd_openr_iovec.  */
 468
 469 static int
 470 gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream,
 471                             struct stat *sb)
 472 {
 473   int fd = *(int *) stream;
 474   int target_errno;
 475   int result;
 476
 477   result = target_fileio_fstat (fd, sb, &target_errno);
 478   if (result == -1)
 479     {
 480       errno = fileio_errno_to_host (target_errno);
 481       bfd_set_error (bfd_error_system_call);
 482     }
 483
 484   return result;
 485 }
 486
 487 /* A helper function to initialize the data that gdb attaches to each
 488    BFD.  */
 489
 490 static void
 491 gdb_bfd_init_data (struct bfd *abfd, struct stat *st)
 492 {
 493   struct gdb_bfd_data *gdata;
 494   void **slot;
 495
 496   gdb_assert (bfd_usrdata (abfd) == nullptr);
 497
 498   /* Ask BFD to decompress sections in bfd_get_full_section_contents.  */
 499   abfd->flags |= BFD_DECOMPRESS;
 500
 501   gdata = new gdb_bfd_data (abfd, st);
 502   bfd_set_usrdata (abfd, gdata);
 503
 504   /* This is the first we've seen it, so add it to the hash table.  */
 505   slot = htab_find_slot (all_bfds, abfd, INSERT);
 506   gdb_assert (slot && !*slot);
 507   *slot = abfd;
 508 }
 509
 510 /* See gdb_bfd.h.  */
 511
 512 gdb_bfd_ref_ptr
 513 gdb_bfd_open (const char *name, const char *target, int fd,
 514               bool warn_if_slow)
 515 {
 516   hashval_t hash;
 517   void **slot;
 518   bfd *abfd;
 519   struct gdb_bfd_cache_search search;
 520   struct stat st;
 521
 522   if (is_target_filename (name))
 523     {
 524       if (!target_filesystem_is_local ())
 525         {
 526           gdb_assert (fd == -1);
 527
 528           gdb_bfd_open_closure open_closure { current_inferior (), warn_if_slow };
 529           return gdb_bfd_openr_iovec (name, target,
 530                                       gdb_bfd_iovec_fileio_open,
 531                                       &open_closure,
 532                                       gdb_bfd_iovec_fileio_pread,
 533                                       gdb_bfd_iovec_fileio_close,
 534                                       gdb_bfd_iovec_fileio_fstat);
 535         }
 536
 537       name += strlen (TARGET_SYSROOT_PREFIX);
 538     }
 539
 540   if (gdb_bfd_cache == NULL)
 541     gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
 542                                        xcalloc, xfree);
 543
 544   if (fd == -1)
 545     {
 546       fd = gdb_open_cloexec (name, O_RDONLY | O_BINARY, 0).release ();
 547       if (fd == -1)
 548         {
 549           bfd_set_error (bfd_error_system_call);
 550           return NULL;
 551         }
 552     }
 553
 554   if (fstat (fd, &st) < 0)
 555     {
 556       /* Weird situation here -- don't cache if we can't stat.  */
 557       bfd_cache_debug_printf ("Could not stat %s - not caching", name);
 558       abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 559       if (abfd == nullptr)
 560         return nullptr;
 561       return gdb_bfd_ref_ptr::new_reference (abfd);
 562     }
 563
 564   search.filename = name;
 565   search.mtime = st.st_mtime;
 566   search.size = st.st_size;
 567   search.inode = st.st_ino;
 568   search.device_id = st.st_dev;
 569
 570   /* Note that this must compute the same result as hash_bfd.  */
 571   hash = htab_hash_string (name);
 572   /* Note that we cannot use htab_find_slot_with_hash here, because
 573      opening the BFD may fail; and this would violate hashtab
 574      invariants.  */
 575   abfd = (struct bfd *) htab_find_with_hash (gdb_bfd_cache, &search, hash);
 576   if (bfd_sharing && abfd != NULL)
 577     {
 578       bfd_cache_debug_printf ("Reusing cached bfd %s for %s",
 579                               host_address_to_string (abfd),
 580                               bfd_get_filename (abfd));
 581       close (fd);
 582       return gdb_bfd_ref_ptr::new_reference (abfd);
 583     }
 584
 585   abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 586   if (abfd == NULL)
 587     return NULL;
 588
 589   bfd_cache_debug_printf ("Creating new bfd %s for %s",
 590                           host_address_to_string (abfd),
 591                           bfd_get_filename (abfd));
 592
 593   if (bfd_sharing)
 594     {
 595       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
 596       gdb_assert (!*slot);
 597       *slot = abfd;
 598     }
 599
 600   /* It's important to pass the already-computed stat info here,
 601      rather than, say, calling gdb_bfd_ref_ptr::new_reference.  BFD by
 602      default will "stat" the file each time bfd_get_mtime is called --
 603      and since we already entered it into the hash table using this
 604      mtime, if the file changed at the wrong moment, the race would
 605      lead to a hash table corruption.  */
 606   gdb_bfd_init_data (abfd, &st);
 607   return gdb_bfd_ref_ptr (abfd);
 608 }
 609
 610 /* A helper function that releases any section data attached to the
 611    BFD.  */
 612
 613 static void
 614 free_one_bfd_section (asection *sectp)
 615 {
 616   struct gdb_bfd_section_data *sect
 617     = (struct gdb_bfd_section_data *) bfd_section_userdata (sectp);
 618
 619   if (sect != NULL && sect->data != NULL)
 620     {
 621 #ifdef HAVE_MMAP
 622       if (sect->map_addr != NULL)
 623         {
 624           int res;
 625
 626           res = munmap (sect->map_addr, sect->map_len);
 627           gdb_assert (res == 0);
 628         }
 629       else
 630 #endif
 631         xfree (sect->data);
 632     }
 633 }
 634
 635 /* Close ABFD, and warn if that fails.  */
 636
 637 static int
 638 gdb_bfd_close_or_warn (struct bfd *abfd)
 639 {
 640   int ret;
 641   const char *name = bfd_get_filename (abfd);
 642
 643   for (asection *sect : gdb_bfd_sections (abfd))
 644     free_one_bfd_section (sect);
 645
 646   ret = bfd_close (abfd);
 647
 648   if (!ret)
 649     gdb_bfd_close_warning (name,
 650                            bfd_errmsg (bfd_get_error ()));
 651
 652   return ret;
 653 }
 654
 655 /* See gdb_bfd.h.  */
 656
 657 void
 658 gdb_bfd_ref (struct bfd *abfd)
 659 {
 660   struct gdb_bfd_data *gdata;
 661
 662   if (abfd == NULL)
 663     return;
 664
 665   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 666
 667   bfd_cache_debug_printf ("Increase reference count on bfd %s (%s)",
 668                           host_address_to_string (abfd),
 669                           bfd_get_filename (abfd));
 670
 671   if (gdata != NULL)
 672     {
 673       gdata->refc += 1;
 674       return;
 675     }
 676
 677   /* Caching only happens via gdb_bfd_open, so passing nullptr here is
 678      fine.  */
 679   gdb_bfd_init_data (abfd, nullptr);
 680 }
 681
 682 /* See gdb_bfd.h.  */
 683
 684 void
 685 gdb_bfd_unref (struct bfd *abfd)
 686 {
 687   struct gdb_bfd_data *gdata;
 688   struct gdb_bfd_cache_search search;
 689   bfd *archive_bfd;
 690
 691   if (abfd == NULL)
 692     return;
 693
 694   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 695   gdb_assert (gdata->refc >= 1);
 696
 697   gdata->refc -= 1;
 698   if (gdata->refc > 0)
 699     {
 700       bfd_cache_debug_printf ("Decrease reference count on bfd %s (%s)",
 701                               host_address_to_string (abfd),
 702                               bfd_get_filename (abfd));
 703       return;
 704     }
 705
 706   bfd_cache_debug_printf ("Delete final reference count on bfd %s (%s)",
 707                           host_address_to_string (abfd),
 708                           bfd_get_filename (abfd));
 709
 710   archive_bfd = gdata->archive_bfd;
 711   search.filename = bfd_get_filename (abfd);
 712
 713   if (gdb_bfd_cache && search.filename)
 714     {
 715       hashval_t hash = htab_hash_string (search.filename);
 716       void **slot;
 717
 718       search.mtime = gdata->mtime;
 719       search.size = gdata->size;
 720       search.inode = gdata->inode;
 721       search.device_id = gdata->device_id;
 722       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 723                                        NO_INSERT);
 724
 725       if (slot && *slot)
 726         htab_clear_slot (gdb_bfd_cache, slot);
 727     }
 728
 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 }