gdb/gdb_bfd.c

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