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