gdb/gdb_bfd.c

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