gdb/gdb_bfd.c

   1 /* Definitions for BFD wrappers used by GDB.
   2
   3    Copyright (C) 2011-2020 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
 211 /* Return the system error number corresponding to ERRNUM.  */
 212
 213 static int
 214 fileio_errno_to_host (int errnum)
 215 {
 216   switch (errnum)
 217     {
 218       case FILEIO_EPERM:
 219         return EPERM;
 220       case FILEIO_ENOENT:
 221         return ENOENT;
 222       case FILEIO_EINTR:
 223         return EINTR;
 224       case FILEIO_EIO:
 225         return EIO;
 226       case FILEIO_EBADF:
 227         return EBADF;
 228       case FILEIO_EACCES:
 229         return EACCES;
 230       case FILEIO_EFAULT:
 231         return EFAULT;
 232       case FILEIO_EBUSY:
 233         return EBUSY;
 234       case FILEIO_EEXIST:
 235         return EEXIST;
 236       case FILEIO_ENODEV:
 237         return ENODEV;
 238       case FILEIO_ENOTDIR:
 239         return ENOTDIR;
 240       case FILEIO_EISDIR:
 241         return EISDIR;
 242       case FILEIO_EINVAL:
 243         return EINVAL;
 244       case FILEIO_ENFILE:
 245         return ENFILE;
 246       case FILEIO_EMFILE:
 247         return EMFILE;
 248       case FILEIO_EFBIG:
 249         return EFBIG;
 250       case FILEIO_ENOSPC:
 251         return ENOSPC;
 252       case FILEIO_ESPIPE:
 253         return ESPIPE;
 254       case FILEIO_EROFS:
 255         return EROFS;
 256       case FILEIO_ENOSYS:
 257         return ENOSYS;
 258       case FILEIO_ENAMETOOLONG:
 259         return ENAMETOOLONG;
 260     }
 261   return -1;
 262 }
 263
 264 /* bfd_openr_iovec OPEN_CLOSURE data for gdb_bfd_open.  */
 265 struct gdb_bfd_open_closure
 266 {
 267   inferior *inf;
 268   bool warn_if_slow;
 269 };
 270
 271 /* Wrapper for target_fileio_open suitable for passing as the
 272    OPEN_FUNC argument to gdb_bfd_openr_iovec.  */
 273
 274 static void *
 275 gdb_bfd_iovec_fileio_open (struct bfd *abfd, void *open_closure)
 276 {
 277   const char *filename = bfd_get_filename (abfd);
 278   int fd, target_errno;
 279   int *stream;
 280   gdb_bfd_open_closure *oclosure = (gdb_bfd_open_closure *) open_closure;
 281
 282   gdb_assert (is_target_filename (filename));
 283
 284   fd = target_fileio_open (oclosure->inf,
 285                            filename + strlen (TARGET_SYSROOT_PREFIX),
 286                            FILEIO_O_RDONLY, 0, oclosure->warn_if_slow,
 287                            &target_errno);
 288   if (fd == -1)
 289     {
 290       errno = fileio_errno_to_host (target_errno);
 291       bfd_set_error (bfd_error_system_call);
 292       return NULL;
 293     }
 294
 295   stream = XCNEW (int);
 296   *stream = fd;
 297   return stream;
 298 }
 299
 300 /* Wrapper for target_fileio_pread suitable for passing as the
 301    PREAD_FUNC argument to gdb_bfd_openr_iovec.  */
 302
 303 static file_ptr
 304 gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf,
 305                             file_ptr nbytes, file_ptr offset)
 306 {
 307   int fd = *(int *) stream;
 308   int target_errno;
 309   file_ptr pos, bytes;
 310
 311   pos = 0;
 312   while (nbytes > pos)
 313     {
 314       QUIT;
 315
 316       bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos,
 317                                    nbytes - pos, offset + pos,
 318                                    &target_errno);
 319       if (bytes == 0)
 320         /* Success, but no bytes, means end-of-file.  */
 321         break;
 322       if (bytes == -1)
 323         {
 324           errno = fileio_errno_to_host (target_errno);
 325           bfd_set_error (bfd_error_system_call);
 326           return -1;
 327         }
 328
 329       pos += bytes;
 330     }
 331
 332   return pos;
 333 }
 334
 335 /* Wrapper for target_fileio_close suitable for passing as the
 336    CLOSE_FUNC argument to gdb_bfd_openr_iovec.  */
 337
 338 static int
 339 gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream)
 340 {
 341   int fd = *(int *) stream;
 342   int target_errno;
 343
 344   xfree (stream);
 345
 346   /* Ignore errors on close.  These may happen with remote
 347      targets if the connection has already been torn down.  */
 348   target_fileio_close (fd, &target_errno);
 349
 350   /* Zero means success.  */
 351   return 0;
 352 }
 353
 354 /* Wrapper for target_fileio_fstat suitable for passing as the
 355    STAT_FUNC argument to gdb_bfd_openr_iovec.  */
 356
 357 static int
 358 gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream,
 359                             struct stat *sb)
 360 {
 361   int fd = *(int *) stream;
 362   int target_errno;
 363   int result;
 364
 365   result = target_fileio_fstat (fd, sb, &target_errno);
 366   if (result == -1)
 367     {
 368       errno = fileio_errno_to_host (target_errno);
 369       bfd_set_error (bfd_error_system_call);
 370     }
 371
 372   return result;
 373 }
 374
 375 /* A helper function to initialize the data that gdb attaches to each
 376    BFD.  */
 377
 378 static void
 379 gdb_bfd_init_data (struct bfd *abfd, struct stat *st)
 380 {
 381   struct gdb_bfd_data *gdata;
 382   void **slot;
 383
 384   gdb_assert (bfd_usrdata (abfd) == nullptr);
 385
 386   /* Ask BFD to decompress sections in bfd_get_full_section_contents.  */
 387   abfd->flags |= BFD_DECOMPRESS;
 388
 389   gdata = new gdb_bfd_data (abfd, st);
 390   bfd_set_usrdata (abfd, gdata);
 391   bfd_alloc_data (abfd);
 392
 393   /* This is the first we've seen it, so add it to the hash table.  */
 394   slot = htab_find_slot (all_bfds, abfd, INSERT);
 395   gdb_assert (slot && !*slot);
 396   *slot = abfd;
 397 }
 398
 399 /* See gdb_bfd.h.  */
 400
 401 gdb_bfd_ref_ptr
 402 gdb_bfd_open (const char *name, const char *target, int fd,
 403               bool warn_if_slow)
 404 {
 405   hashval_t hash;
 406   void **slot;
 407   bfd *abfd;
 408   struct gdb_bfd_cache_search search;
 409   struct stat st;
 410
 411   if (is_target_filename (name))
 412     {
 413       if (!target_filesystem_is_local ())
 414         {
 415           gdb_assert (fd == -1);
 416
 417           gdb_bfd_open_closure open_closure { current_inferior (), warn_if_slow };
 418           return gdb_bfd_openr_iovec (name, target,
 419                                       gdb_bfd_iovec_fileio_open,
 420                                       &open_closure,
 421                                       gdb_bfd_iovec_fileio_pread,
 422                                       gdb_bfd_iovec_fileio_close,
 423                                       gdb_bfd_iovec_fileio_fstat);
 424         }
 425
 426       name += strlen (TARGET_SYSROOT_PREFIX);
 427     }
 428
 429   if (gdb_bfd_cache == NULL)
 430     gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
 431                                        xcalloc, xfree);
 432
 433   if (fd == -1)
 434     {
 435       fd = gdb_open_cloexec (name, O_RDONLY | O_BINARY, 0);
 436       if (fd == -1)
 437         {
 438           bfd_set_error (bfd_error_system_call);
 439           return NULL;
 440         }
 441     }
 442
 443   if (fstat (fd, &st) < 0)
 444     {
 445       /* Weird situation here -- don't cache if we can't stat.  */
 446       if (debug_bfd_cache)
 447         fprintf_unfiltered (gdb_stdlog,
 448                             "Could not stat %s - not caching\n",
 449                             name);
 450       abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 451       if (abfd == nullptr)
 452         return nullptr;
 453       return gdb_bfd_ref_ptr::new_reference (abfd);
 454     }
 455
 456   search.filename = name;
 457   search.mtime = st.st_mtime;
 458   search.size = st.st_size;
 459   search.inode = st.st_ino;
 460   search.device_id = st.st_dev;
 461
 462   /* Note that this must compute the same result as hash_bfd.  */
 463   hash = htab_hash_string (name);
 464   /* Note that we cannot use htab_find_slot_with_hash here, because
 465      opening the BFD may fail; and this would violate hashtab
 466      invariants.  */
 467   abfd = (struct bfd *) htab_find_with_hash (gdb_bfd_cache, &search, hash);
 468   if (bfd_sharing && abfd != NULL)
 469     {
 470       if (debug_bfd_cache)
 471         fprintf_unfiltered (gdb_stdlog,
 472                             "Reusing cached bfd %s for %s\n",
 473                             host_address_to_string (abfd),
 474                             bfd_get_filename (abfd));
 475       close (fd);
 476       return gdb_bfd_ref_ptr::new_reference (abfd);
 477     }
 478
 479   abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 480   if (abfd == NULL)
 481     return NULL;
 482
 483   if (debug_bfd_cache)
 484     fprintf_unfiltered (gdb_stdlog,
 485                         "Creating new bfd %s for %s\n",
 486                         host_address_to_string (abfd),
 487                         bfd_get_filename (abfd));
 488
 489   if (bfd_sharing)
 490     {
 491       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
 492       gdb_assert (!*slot);
 493       *slot = abfd;
 494     }
 495
 496   /* It's important to pass the already-computed stat info here,
 497      rather than, say, calling gdb_bfd_ref_ptr::new_reference.  BFD by
 498      default will "stat" the file each time bfd_get_mtime is called --
 499      and since we already entered it into the hash table using this
 500      mtime, if the file changed at the wrong moment, the race would
 501      lead to a hash table corruption.  */
 502   gdb_bfd_init_data (abfd, &st);
 503   return gdb_bfd_ref_ptr (abfd);
 504 }
 505
 506 /* A helper function that releases any section data attached to the
 507    BFD.  */
 508
 509 static void
 510 free_one_bfd_section (asection *sectp)
 511 {
 512   struct gdb_bfd_section_data *sect
 513     = (struct gdb_bfd_section_data *) bfd_section_userdata (sectp);
 514
 515   if (sect != NULL && sect->data != NULL)
 516     {
 517 #ifdef HAVE_MMAP
 518       if (sect->map_addr != NULL)
 519         {
 520           int res;
 521
 522           res = munmap (sect->map_addr, sect->map_len);
 523           gdb_assert (res == 0);
 524         }
 525       else
 526 #endif
 527         xfree (sect->data);
 528     }
 529 }
 530
 531 /* Close ABFD, and warn if that fails.  */
 532
 533 static int
 534 gdb_bfd_close_or_warn (struct bfd *abfd)
 535 {
 536   int ret;
 537   const char *name = bfd_get_filename (abfd);
 538
 539   for (asection *sect : gdb_bfd_sections (abfd))
 540     free_one_bfd_section (sect);
 541
 542   ret = bfd_close (abfd);
 543
 544   if (!ret)
 545     warning (_("cannot close \"%s\": %s"),
 546              name, bfd_errmsg (bfd_get_error ()));
 547
 548   return ret;
 549 }
 550
 551 /* See gdb_bfd.h.  */
 552
 553 void
 554 gdb_bfd_ref (struct bfd *abfd)
 555 {
 556   struct gdb_bfd_data *gdata;
 557
 558   if (abfd == NULL)
 559     return;
 560
 561   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 562
 563   if (debug_bfd_cache)
 564     fprintf_unfiltered (gdb_stdlog,
 565                         "Increase reference count on bfd %s (%s)\n",
 566                         host_address_to_string (abfd),
 567                         bfd_get_filename (abfd));
 568
 569   if (gdata != NULL)
 570     {
 571       gdata->refc += 1;
 572       return;
 573     }
 574
 575   /* Caching only happens via gdb_bfd_open, so passing nullptr here is
 576      fine.  */
 577   gdb_bfd_init_data (abfd, nullptr);
 578 }
 579
 580 /* See gdb_bfd.h.  */
 581
 582 void
 583 gdb_bfd_unref (struct bfd *abfd)
 584 {
 585   struct gdb_bfd_data *gdata;
 586   struct gdb_bfd_cache_search search;
 587   bfd *archive_bfd;
 588
 589   if (abfd == NULL)
 590     return;
 591
 592   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 593   gdb_assert (gdata->refc >= 1);
 594
 595   gdata->refc -= 1;
 596   if (gdata->refc > 0)
 597     {
 598       if (debug_bfd_cache)
 599         fprintf_unfiltered (gdb_stdlog,
 600                             "Decrease reference count on bfd %s (%s)\n",
 601                             host_address_to_string (abfd),
 602                             bfd_get_filename (abfd));
 603       return;
 604     }
 605
 606   if (debug_bfd_cache)
 607     fprintf_unfiltered (gdb_stdlog,
 608                         "Delete final reference count on bfd %s (%s)\n",
 609                         host_address_to_string (abfd),
 610                         bfd_get_filename (abfd));
 611
 612   archive_bfd = gdata->archive_bfd;
 613   search.filename = bfd_get_filename (abfd);
 614
 615   if (gdb_bfd_cache && search.filename)
 616     {
 617       hashval_t hash = htab_hash_string (search.filename);
 618       void **slot;
 619
 620       search.mtime = gdata->mtime;
 621       search.size = gdata->size;
 622       search.inode = gdata->inode;
 623       search.device_id = gdata->device_id;
 624       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 625                                        NO_INSERT);
 626
 627       if (slot && *slot)
 628         htab_clear_slot (gdb_bfd_cache, slot);
 629     }
 630
 631   bfd_free_data (abfd);
 632   delete gdata;
 633   bfd_set_usrdata (abfd, NULL);  /* Paranoia.  */
 634
 635   htab_remove_elt (all_bfds, abfd);
 636
 637   gdb_bfd_close_or_warn (abfd);
 638
 639   gdb_bfd_unref (archive_bfd);
 640 }
 641
 642 /* A helper function that returns the section data descriptor
 643    associated with SECTION.  If no such descriptor exists, a new one
 644    is allocated and cleared.  */
 645
 646 static struct gdb_bfd_section_data *
 647 get_section_descriptor (asection *section)
 648 {
 649   struct gdb_bfd_section_data *result;
 650
 651   result = (struct gdb_bfd_section_data *) bfd_section_userdata (section);
 652
 653   if (result == NULL)
 654     {
 655       result = ((struct gdb_bfd_section_data *)
 656                 bfd_zalloc (section->owner, sizeof (*result)));
 657       bfd_set_section_userdata (section, result);
 658     }
 659
 660   return result;
 661 }
 662
 663 /* See gdb_bfd.h.  */
 664
 665 const gdb_byte *
 666 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 667 {
 668   bfd *abfd;
 669   struct gdb_bfd_section_data *descriptor;
 670   bfd_byte *data;
 671
 672   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 673   gdb_assert (size != NULL);
 674
 675   abfd = sectp->owner;
 676
 677   descriptor = get_section_descriptor (sectp);
 678
 679   /* If the data was already read for this BFD, just reuse it.  */
 680   if (descriptor->data != NULL)
 681     goto done;
 682
 683 #ifdef HAVE_MMAP
 684   if (!bfd_is_section_compressed (abfd, sectp))
 685     {
 686       /* The page size, used when mmapping.  */
 687       static int pagesize;
 688
 689       if (pagesize == 0)
 690         pagesize = getpagesize ();
 691
 692       /* Only try to mmap sections which are large enough: we don't want
 693          to waste space due to fragmentation.  */
 694
 695       if (bfd_section_size (sectp) > 4 * pagesize)
 696         {
 697           descriptor->size = bfd_section_size (sectp);
 698           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 699                                        MAP_PRIVATE, sectp->filepos,
 700                                        &descriptor->map_addr,
 701                                        &descriptor->map_len);
 702
 703           if ((caddr_t)descriptor->data != MAP_FAILED)
 704             {
 705 #if HAVE_POSIX_MADVISE
 706               posix_madvise (descriptor->map_addr, descriptor->map_len,
 707                              POSIX_MADV_WILLNEED);
 708 #endif
 709               goto done;
 710             }
 711
 712           /* On failure, clear out the section data and try again.  */
 713           memset (descriptor, 0, sizeof (*descriptor));
 714         }
 715     }
 716 #endif /* HAVE_MMAP */
 717
 718   /* Handle compressed sections, or ordinary uncompressed sections in
 719      the no-mmap case.  */
 720
 721   descriptor->size = bfd_section_size (sectp);
 722   descriptor->data = NULL;
 723
 724   data = NULL;
 725   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 726     {
 727       warning (_("Can't read data for section '%s' in file '%s'"),
 728                bfd_section_name (sectp),
 729                bfd_get_filename (abfd));
 730       /* Set size to 0 to prevent further attempts to read the invalid
 731          section.  */
 732       *size = 0;
 733       return NULL;
 734     }
 735   descriptor->data = data;
 736
 737  done:
 738   gdb_assert (descriptor->data != NULL);
 739   *size = descriptor->size;
 740   return (const gdb_byte *) descriptor->data;
 741 }
 742
 743 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 744    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 745    not preserved.  */
 746
 747 static int
 748 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 749 {
 750   unsigned long file_crc = 0;
 751
 752   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 753     {
 754       warning (_("Problem reading \"%s\" for CRC: %s"),
 755                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 756       return 0;
 757     }
 758
 759   for (;;)
 760     {
 761       gdb_byte buffer[8 * 1024];
 762       bfd_size_type count;
 763
 764       count = bfd_bread (buffer, sizeof (buffer), abfd);
 765       if (count == (bfd_size_type) -1)
 766         {
 767           warning (_("Problem reading \"%s\" for CRC: %s"),
 768                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 769           return 0;
 770         }
 771       if (count == 0)
 772         break;
 773       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 774     }
 775
 776   *file_crc_return = file_crc;
 777   return 1;
 778 }
 779
 780 /* See gdb_bfd.h.  */
 781
 782 int
 783 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 784 {
 785   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 786
 787   if (!gdata->crc_computed)
 788     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 789
 790   if (gdata->crc_computed)
 791     *crc_out = gdata->crc;
 792   return gdata->crc_computed;
 793 }
 794
 795 \f
 796
 797 /* See gdb_bfd.h.  */
 798
 799 gdb_bfd_ref_ptr
 800 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 801                int fd)
 802 {
 803   bfd *result = bfd_fopen (filename, target, mode, fd);
 804
 805   return gdb_bfd_ref_ptr::new_reference (result);
 806 }
 807
 808 /* See gdb_bfd.h.  */
 809
 810 gdb_bfd_ref_ptr
 811 gdb_bfd_openr (const char *filename, const char *target)
 812 {
 813   bfd *result = bfd_openr (filename, target);
 814
 815   return gdb_bfd_ref_ptr::new_reference (result);
 816 }
 817
 818 /* See gdb_bfd.h.  */
 819
 820 gdb_bfd_ref_ptr
 821 gdb_bfd_openw (const char *filename, const char *target)
 822 {
 823   bfd *result = bfd_openw (filename, target);
 824
 825   return gdb_bfd_ref_ptr::new_reference (result);
 826 }
 827
 828 /* See gdb_bfd.h.  */
 829
 830 gdb_bfd_ref_ptr
 831 gdb_bfd_openr_iovec (const char *filename, const char *target,
 832                      void *(*open_func) (struct bfd *nbfd,
 833                                          void *open_closure),
 834                      void *open_closure,
 835                      file_ptr (*pread_func) (struct bfd *nbfd,
 836                                              void *stream,
 837                                              void *buf,
 838                                              file_ptr nbytes,
 839                                              file_ptr offset),
 840                      int (*close_func) (struct bfd *nbfd,
 841                                         void *stream),
 842                      int (*stat_func) (struct bfd *abfd,
 843                                        void *stream,
 844                                        struct stat *sb))
 845 {
 846   bfd *result = bfd_openr_iovec (filename, target,
 847                                  open_func, open_closure,
 848                                  pread_func, close_func, stat_func);
 849
 850   return gdb_bfd_ref_ptr::new_reference (result);
 851 }
 852
 853 /* See gdb_bfd.h.  */
 854
 855 void
 856 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 857 {
 858   struct gdb_bfd_data *gdata;
 859
 860   gdb_bfd_ref (child);
 861   /* No need to stash the filename here, because we also keep a
 862      reference on the parent archive.  */
 863
 864   gdata = (struct gdb_bfd_data *) bfd_usrdata (child);
 865   if (gdata->archive_bfd == NULL)
 866     {
 867       gdata->archive_bfd = parent;
 868       gdb_bfd_ref (parent);
 869     }
 870   else
 871     gdb_assert (gdata->archive_bfd == parent);
 872 }
 873
 874 /* See gdb_bfd.h.  */
 875
 876 gdb_bfd_ref_ptr
 877 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 878 {
 879   bfd *result = bfd_openr_next_archived_file (archive, previous);
 880
 881   if (result)
 882     gdb_bfd_mark_parent (result, archive);
 883
 884   return gdb_bfd_ref_ptr (result);
 885 }
 886
 887 /* See gdb_bfd.h.  */
 888
 889 void
 890 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 891 {
 892   struct gdb_bfd_data *gdata;
 893
 894   gdata = (struct gdb_bfd_data *) bfd_usrdata (includer);
 895   gdata->included_bfds.push_back (gdb_bfd_ref_ptr::new_reference (includee));
 896 }
 897
 898 \f
 899
 900 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 901
 902 /* See gdb_bfd.h.  */
 903
 904 int
 905 gdb_bfd_section_index (bfd *abfd, asection *section)
 906 {
 907   if (section == NULL)
 908     return -1;
 909   else if (section == bfd_com_section_ptr)
 910     return bfd_count_sections (abfd);
 911   else if (section == bfd_und_section_ptr)
 912     return bfd_count_sections (abfd) + 1;
 913   else if (section == bfd_abs_section_ptr)
 914     return bfd_count_sections (abfd) + 2;
 915   else if (section == bfd_ind_section_ptr)
 916     return bfd_count_sections (abfd) + 3;
 917   return section->index;
 918 }
 919
 920 /* See gdb_bfd.h.  */
 921
 922 int
 923 gdb_bfd_count_sections (bfd *abfd)
 924 {
 925   return bfd_count_sections (abfd) + 4;
 926 }
 927
 928 /* See gdb_bfd.h.  */
 929
 930 int
 931 gdb_bfd_requires_relocations (bfd *abfd)
 932 {
 933   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 934
 935   if (gdata->relocation_computed == 0)
 936     {
 937       asection *sect;
 938
 939       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 940         if ((sect->flags & SEC_RELOC) != 0)
 941           {
 942             gdata->needs_relocations = 1;
 943             break;
 944           }
 945
 946       gdata->relocation_computed = 1;
 947     }
 948
 949   return gdata->needs_relocations;
 950 }
 951
 952 /* See gdb_bfd.h.  */
 953
 954 bool
 955 gdb_bfd_get_full_section_contents (bfd *abfd, asection *section,
 956                                    gdb::byte_vector *contents)
 957 {
 958   bfd_size_type section_size = bfd_section_size (section);
 959
 960   contents->resize (section_size);
 961
 962   return bfd_get_section_contents (abfd, section, contents->data (), 0,
 963                                    section_size);
 964 }
 965
 966 /* A callback for htab_traverse that prints a single BFD.  */
 967
 968 static int
 969 print_one_bfd (void **slot, void *data)
 970 {
 971   bfd *abfd = (struct bfd *) *slot;
 972   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 973   struct ui_out *uiout = (struct ui_out *) data;
 974
 975   ui_out_emit_tuple tuple_emitter (uiout, NULL);
 976   uiout->field_signed ("refcount", gdata->refc);
 977   uiout->field_string ("addr", host_address_to_string (abfd));
 978   uiout->field_string ("filename", bfd_get_filename (abfd));
 979   uiout->text ("\n");
 980
 981   return 1;
 982 }
 983
 984 /* Implement the 'maint info bfd' command.  */
 985
 986 static void
 987 maintenance_info_bfds (const char *arg, int from_tty)
 988 {
 989   struct ui_out *uiout = current_uiout;
 990
 991   ui_out_emit_table table_emitter (uiout, 3, -1, "bfds");
 992   uiout->table_header (10, ui_left, "refcount", "Refcount");
 993   uiout->table_header (18, ui_left, "addr", "Address");
 994   uiout->table_header (40, ui_left, "filename", "Filename");
 995
 996   uiout->table_body ();
 997   htab_traverse (all_bfds, print_one_bfd, uiout);
 998 }
 999
1000 void _initialize_gdb_bfd ();
1001 void
1002 _initialize_gdb_bfd ()
1003 {
1004   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
1005                                 NULL, xcalloc, xfree);
1006
1007   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
1008 List the BFDs that are currently open."),
1009            &maintenanceinfolist);
1010
1011   add_setshow_boolean_cmd ("bfd-sharing", no_class,
1012                            &bfd_sharing, _("\
1013 Set whether gdb will share bfds that appear to be the same file."), _("\
1014 Show whether gdb will share bfds that appear to be the same file."), _("\
1015 When enabled gdb will reuse existing bfds rather than reopening the\n\
1016 same file.  To decide if two files are the same then gdb compares the\n\
1017 filename, file size, file modification time, and file inode."),
1018                            NULL,
1019                            &show_bfd_sharing,
1020                            &maintenance_set_cmdlist,
1021                            &maintenance_show_cmdlist);
1022
1023   add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
1024                              &debug_bfd_cache, _("\
1025 Set bfd cache debugging."), _("\
1026 Show bfd cache debugging."), _("\
1027 When non-zero, bfd cache specific debugging is enabled."),
1028                              NULL,
1029                              &show_bfd_cache_debug,
1030                              &setdebuglist, &showdebuglist);
1031 }