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 (bfd *abfd, asection *sectp, void *ignore)
 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   bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
 540
 541   ret = bfd_close (abfd);
 542
 543   if (!ret)
 544     warning (_("cannot close \"%s\": %s"),
 545              name, bfd_errmsg (bfd_get_error ()));
 546
 547   return ret;
 548 }
 549
 550 /* See gdb_bfd.h.  */
 551
 552 void
 553 gdb_bfd_ref (struct bfd *abfd)
 554 {
 555   struct gdb_bfd_data *gdata;
 556
 557   if (abfd == NULL)
 558     return;
 559
 560   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 561
 562   if (debug_bfd_cache)
 563     fprintf_unfiltered (gdb_stdlog,
 564                         "Increase reference count on bfd %s (%s)\n",
 565                         host_address_to_string (abfd),
 566                         bfd_get_filename (abfd));
 567
 568   if (gdata != NULL)
 569     {
 570       gdata->refc += 1;
 571       return;
 572     }
 573
 574   /* Caching only happens via gdb_bfd_open, so passing nullptr here is
 575      fine.  */
 576   gdb_bfd_init_data (abfd, nullptr);
 577 }
 578
 579 /* See gdb_bfd.h.  */
 580
 581 void
 582 gdb_bfd_unref (struct bfd *abfd)
 583 {
 584   struct gdb_bfd_data *gdata;
 585   struct gdb_bfd_cache_search search;
 586   bfd *archive_bfd;
 587
 588   if (abfd == NULL)
 589     return;
 590
 591   gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 592   gdb_assert (gdata->refc >= 1);
 593
 594   gdata->refc -= 1;
 595   if (gdata->refc > 0)
 596     {
 597       if (debug_bfd_cache)
 598         fprintf_unfiltered (gdb_stdlog,
 599                             "Decrease reference count on bfd %s (%s)\n",
 600                             host_address_to_string (abfd),
 601                             bfd_get_filename (abfd));
 602       return;
 603     }
 604
 605   if (debug_bfd_cache)
 606     fprintf_unfiltered (gdb_stdlog,
 607                         "Delete final reference count on bfd %s (%s)\n",
 608                         host_address_to_string (abfd),
 609                         bfd_get_filename (abfd));
 610
 611   archive_bfd = gdata->archive_bfd;
 612   search.filename = bfd_get_filename (abfd);
 613
 614   if (gdb_bfd_cache && search.filename)
 615     {
 616       hashval_t hash = htab_hash_string (search.filename);
 617       void **slot;
 618
 619       search.mtime = gdata->mtime;
 620       search.size = gdata->size;
 621       search.inode = gdata->inode;
 622       search.device_id = gdata->device_id;
 623       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 624                                        NO_INSERT);
 625
 626       if (slot && *slot)
 627         htab_clear_slot (gdb_bfd_cache, slot);
 628     }
 629
 630   bfd_free_data (abfd);
 631   delete gdata;
 632   bfd_set_usrdata (abfd, NULL);  /* Paranoia.  */
 633
 634   htab_remove_elt (all_bfds, abfd);
 635
 636   gdb_bfd_close_or_warn (abfd);
 637
 638   gdb_bfd_unref (archive_bfd);
 639 }
 640
 641 /* A helper function that returns the section data descriptor
 642    associated with SECTION.  If no such descriptor exists, a new one
 643    is allocated and cleared.  */
 644
 645 static struct gdb_bfd_section_data *
 646 get_section_descriptor (asection *section)
 647 {
 648   struct gdb_bfd_section_data *result;
 649
 650   result = (struct gdb_bfd_section_data *) bfd_section_userdata (section);
 651
 652   if (result == NULL)
 653     {
 654       result = ((struct gdb_bfd_section_data *)
 655                 bfd_zalloc (section->owner, sizeof (*result)));
 656       bfd_set_section_userdata (section, result);
 657     }
 658
 659   return result;
 660 }
 661
 662 /* See gdb_bfd.h.  */
 663
 664 const gdb_byte *
 665 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 666 {
 667   bfd *abfd;
 668   struct gdb_bfd_section_data *descriptor;
 669   bfd_byte *data;
 670
 671   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 672   gdb_assert (size != NULL);
 673
 674   abfd = sectp->owner;
 675
 676   descriptor = get_section_descriptor (sectp);
 677
 678   /* If the data was already read for this BFD, just reuse it.  */
 679   if (descriptor->data != NULL)
 680     goto done;
 681
 682 #ifdef HAVE_MMAP
 683   if (!bfd_is_section_compressed (abfd, sectp))
 684     {
 685       /* The page size, used when mmapping.  */
 686       static int pagesize;
 687
 688       if (pagesize == 0)
 689         pagesize = getpagesize ();
 690
 691       /* Only try to mmap sections which are large enough: we don't want
 692          to waste space due to fragmentation.  */
 693
 694       if (bfd_section_size (sectp) > 4 * pagesize)
 695         {
 696           descriptor->size = bfd_section_size (sectp);
 697           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 698                                        MAP_PRIVATE, sectp->filepos,
 699                                        &descriptor->map_addr,
 700                                        &descriptor->map_len);
 701
 702           if ((caddr_t)descriptor->data != MAP_FAILED)
 703             {
 704 #if HAVE_POSIX_MADVISE
 705               posix_madvise (descriptor->map_addr, descriptor->map_len,
 706                              POSIX_MADV_WILLNEED);
 707 #endif
 708               goto done;
 709             }
 710
 711           /* On failure, clear out the section data and try again.  */
 712           memset (descriptor, 0, sizeof (*descriptor));
 713         }
 714     }
 715 #endif /* HAVE_MMAP */
 716
 717   /* Handle compressed sections, or ordinary uncompressed sections in
 718      the no-mmap case.  */
 719
 720   descriptor->size = bfd_section_size (sectp);
 721   descriptor->data = NULL;
 722
 723   data = NULL;
 724   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 725     {
 726       warning (_("Can't read data for section '%s' in file '%s'"),
 727                bfd_section_name (sectp),
 728                bfd_get_filename (abfd));
 729       /* Set size to 0 to prevent further attempts to read the invalid
 730          section.  */
 731       *size = 0;
 732       return NULL;
 733     }
 734   descriptor->data = data;
 735
 736  done:
 737   gdb_assert (descriptor->data != NULL);
 738   *size = descriptor->size;
 739   return (const gdb_byte *) descriptor->data;
 740 }
 741
 742 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 743    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 744    not preserved.  */
 745
 746 static int
 747 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 748 {
 749   unsigned long file_crc = 0;
 750
 751   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 752     {
 753       warning (_("Problem reading \"%s\" for CRC: %s"),
 754                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 755       return 0;
 756     }
 757
 758   for (;;)
 759     {
 760       gdb_byte buffer[8 * 1024];
 761       bfd_size_type count;
 762
 763       count = bfd_bread (buffer, sizeof (buffer), abfd);
 764       if (count == (bfd_size_type) -1)
 765         {
 766           warning (_("Problem reading \"%s\" for CRC: %s"),
 767                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 768           return 0;
 769         }
 770       if (count == 0)
 771         break;
 772       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 773     }
 774
 775   *file_crc_return = file_crc;
 776   return 1;
 777 }
 778
 779 /* See gdb_bfd.h.  */
 780
 781 int
 782 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 783 {
 784   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 785
 786   if (!gdata->crc_computed)
 787     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 788
 789   if (gdata->crc_computed)
 790     *crc_out = gdata->crc;
 791   return gdata->crc_computed;
 792 }
 793
 794 \f
 795
 796 /* See gdb_bfd.h.  */
 797
 798 gdb_bfd_ref_ptr
 799 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 800                int fd)
 801 {
 802   bfd *result = bfd_fopen (filename, target, mode, fd);
 803
 804   return gdb_bfd_ref_ptr::new_reference (result);
 805 }
 806
 807 /* See gdb_bfd.h.  */
 808
 809 gdb_bfd_ref_ptr
 810 gdb_bfd_openr (const char *filename, const char *target)
 811 {
 812   bfd *result = bfd_openr (filename, target);
 813
 814   return gdb_bfd_ref_ptr::new_reference (result);
 815 }
 816
 817 /* See gdb_bfd.h.  */
 818
 819 gdb_bfd_ref_ptr
 820 gdb_bfd_openw (const char *filename, const char *target)
 821 {
 822   bfd *result = bfd_openw (filename, target);
 823
 824   return gdb_bfd_ref_ptr::new_reference (result);
 825 }
 826
 827 /* See gdb_bfd.h.  */
 828
 829 gdb_bfd_ref_ptr
 830 gdb_bfd_openr_iovec (const char *filename, const char *target,
 831                      void *(*open_func) (struct bfd *nbfd,
 832                                          void *open_closure),
 833                      void *open_closure,
 834                      file_ptr (*pread_func) (struct bfd *nbfd,
 835                                              void *stream,
 836                                              void *buf,
 837                                              file_ptr nbytes,
 838                                              file_ptr offset),
 839                      int (*close_func) (struct bfd *nbfd,
 840                                         void *stream),
 841                      int (*stat_func) (struct bfd *abfd,
 842                                        void *stream,
 843                                        struct stat *sb))
 844 {
 845   bfd *result = bfd_openr_iovec (filename, target,
 846                                  open_func, open_closure,
 847                                  pread_func, close_func, stat_func);
 848
 849   return gdb_bfd_ref_ptr::new_reference (result);
 850 }
 851
 852 /* See gdb_bfd.h.  */
 853
 854 void
 855 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 856 {
 857   struct gdb_bfd_data *gdata;
 858
 859   gdb_bfd_ref (child);
 860   /* No need to stash the filename here, because we also keep a
 861      reference on the parent archive.  */
 862
 863   gdata = (struct gdb_bfd_data *) bfd_usrdata (child);
 864   if (gdata->archive_bfd == NULL)
 865     {
 866       gdata->archive_bfd = parent;
 867       gdb_bfd_ref (parent);
 868     }
 869   else
 870     gdb_assert (gdata->archive_bfd == parent);
 871 }
 872
 873 /* See gdb_bfd.h.  */
 874
 875 gdb_bfd_ref_ptr
 876 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 877 {
 878   bfd *result = bfd_openr_next_archived_file (archive, previous);
 879
 880   if (result)
 881     gdb_bfd_mark_parent (result, archive);
 882
 883   return gdb_bfd_ref_ptr (result);
 884 }
 885
 886 /* See gdb_bfd.h.  */
 887
 888 void
 889 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 890 {
 891   struct gdb_bfd_data *gdata;
 892
 893   gdata = (struct gdb_bfd_data *) bfd_usrdata (includer);
 894   gdata->included_bfds.push_back (gdb_bfd_ref_ptr::new_reference (includee));
 895 }
 896
 897 \f
 898
 899 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 900
 901 /* See gdb_bfd.h.  */
 902
 903 int
 904 gdb_bfd_section_index (bfd *abfd, asection *section)
 905 {
 906   if (section == NULL)
 907     return -1;
 908   else if (section == bfd_com_section_ptr)
 909     return bfd_count_sections (abfd);
 910   else if (section == bfd_und_section_ptr)
 911     return bfd_count_sections (abfd) + 1;
 912   else if (section == bfd_abs_section_ptr)
 913     return bfd_count_sections (abfd) + 2;
 914   else if (section == bfd_ind_section_ptr)
 915     return bfd_count_sections (abfd) + 3;
 916   return section->index;
 917 }
 918
 919 /* See gdb_bfd.h.  */
 920
 921 int
 922 gdb_bfd_count_sections (bfd *abfd)
 923 {
 924   return bfd_count_sections (abfd) + 4;
 925 }
 926
 927 /* See gdb_bfd.h.  */
 928
 929 int
 930 gdb_bfd_requires_relocations (bfd *abfd)
 931 {
 932   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 933
 934   if (gdata->relocation_computed == 0)
 935     {
 936       asection *sect;
 937
 938       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 939         if ((sect->flags & SEC_RELOC) != 0)
 940           {
 941             gdata->needs_relocations = 1;
 942             break;
 943           }
 944
 945       gdata->relocation_computed = 1;
 946     }
 947
 948   return gdata->needs_relocations;
 949 }
 950
 951 /* See gdb_bfd.h.  */
 952
 953 bool
 954 gdb_bfd_get_full_section_contents (bfd *abfd, asection *section,
 955                                    gdb::byte_vector *contents)
 956 {
 957   bfd_size_type section_size = bfd_section_size (section);
 958
 959   contents->resize (section_size);
 960
 961   return bfd_get_section_contents (abfd, section, contents->data (), 0,
 962                                    section_size);
 963 }
 964
 965 /* A callback for htab_traverse that prints a single BFD.  */
 966
 967 static int
 968 print_one_bfd (void **slot, void *data)
 969 {
 970   bfd *abfd = (struct bfd *) *slot;
 971   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 972   struct ui_out *uiout = (struct ui_out *) data;
 973
 974   ui_out_emit_tuple tuple_emitter (uiout, NULL);
 975   uiout->field_signed ("refcount", gdata->refc);
 976   uiout->field_string ("addr", host_address_to_string (abfd));
 977   uiout->field_string ("filename", bfd_get_filename (abfd));
 978   uiout->text ("\n");
 979
 980   return 1;
 981 }
 982
 983 /* Implement the 'maint info bfd' command.  */
 984
 985 static void
 986 maintenance_info_bfds (const char *arg, int from_tty)
 987 {
 988   struct ui_out *uiout = current_uiout;
 989
 990   ui_out_emit_table table_emitter (uiout, 3, -1, "bfds");
 991   uiout->table_header (10, ui_left, "refcount", "Refcount");
 992   uiout->table_header (18, ui_left, "addr", "Address");
 993   uiout->table_header (40, ui_left, "filename", "Filename");
 994
 995   uiout->table_body ();
 996   htab_traverse (all_bfds, print_one_bfd, uiout);
 997 }
 998
 999 void _initialize_gdb_bfd ();
1000 void
1001 _initialize_gdb_bfd ()
1002 {
1003   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
1004                                 NULL, xcalloc, xfree);
1005
1006   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
1007 List the BFDs that are currently open."),
1008            &maintenanceinfolist);
1009
1010   add_setshow_boolean_cmd ("bfd-sharing", no_class,
1011                            &bfd_sharing, _("\
1012 Set whether gdb will share bfds that appear to be the same file."), _("\
1013 Show whether gdb will share bfds that appear to be the same file."), _("\
1014 When enabled gdb will reuse existing bfds rather than reopening the\n\
1015 same file.  To decide if two files are the same then gdb compares the\n\
1016 filename, file size, file modification time, and file inode."),
1017                            NULL,
1018                            &show_bfd_sharing,
1019                            &maintenance_set_cmdlist,
1020                            &maintenance_show_cmdlist);
1021
1022   add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
1023                              &debug_bfd_cache, _("\
1024 Set bfd cache debugging."), _("\
1025 Show bfd cache debugging."), _("\
1026 When non-zero, bfd cache specific debugging is enabled."),
1027                              NULL,
1028                              &show_bfd_cache_debug,
1029                              &setdebuglist, &showdebuglist);
1030 }