gdb/gdb_bfd.c

   1 /* Definitions for BFD wrappers used by GDB.
   2
   3    Copyright (C) 2011-2015 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 "filestuff.h"
  26 #include "vec.h"
  27 #ifdef HAVE_MMAP
  28 #include <sys/mman.h>
  29 #ifndef MAP_FAILED
  30 #define MAP_FAILED ((void *) -1)
  31 #endif
  32 #endif
  33 #include "target.h"
  34 #include "gdb/fileio.h"
  35 #include "inferior.h"
  36
  37 typedef bfd *bfdp;
  38 DEF_VEC_P (bfdp);
  39
  40 /* An object of this type is stored in the section's user data when
  41    mapping a section.  */
  42
  43 struct gdb_bfd_section_data
  44 {
  45   /* Size of the data.  */
  46   bfd_size_type size;
  47   /* If the data was mmapped, this is the length of the map.  */
  48   bfd_size_type map_len;
  49   /* The data.  If NULL, the section data has not been read.  */
  50   void *data;
  51   /* If the data was mmapped, this is the map address.  */
  52   void *map_addr;
  53 };
  54
  55 /* A hash table holding every BFD that gdb knows about.  This is not
  56    to be confused with 'gdb_bfd_cache', which is used for sharing
  57    BFDs; in contrast, this hash is used just to implement
  58    "maint info bfd".  */
  59
  60 static htab_t all_bfds;
  61
  62 /* An object of this type is stored in each BFD's user data.  */
  63
  64 struct gdb_bfd_data
  65 {
  66   /* The reference count.  */
  67   int refc;
  68
  69   /* The mtime of the BFD at the point the cache entry was made.  */
  70   time_t mtime;
  71
  72   /* The file size (in bytes) at the point the cache entry was made.  */
  73   off_t size;
  74
  75   /* The inode of the file at the point the cache entry was made.  */
  76   ino_t inode;
  77
  78   /* The device id of the file at the point the cache entry was made.  */
  79   dev_t device_id;
  80
  81   /* This is true if we have determined whether this BFD has any
  82      sections requiring relocation.  */
  83   unsigned int relocation_computed : 1;
  84
  85   /* This is true if any section needs relocation.  */
  86   unsigned int needs_relocations : 1;
  87
  88   /* This is true if we have successfully computed the file's CRC.  */
  89   unsigned int crc_computed : 1;
  90
  91   /* The file's CRC.  */
  92   unsigned long crc;
  93
  94   /* If the BFD comes from an archive, this points to the archive's
  95      BFD.  Otherwise, this is NULL.  */
  96   bfd *archive_bfd;
  97
  98   /* Table of all the bfds this bfd has included.  */
  99   VEC (bfdp) *included_bfds;
 100
 101   /* The registry.  */
 102   REGISTRY_FIELDS;
 103 };
 104
 105 #define GDB_BFD_DATA_ACCESSOR(ABFD) \
 106   ((struct gdb_bfd_data *) bfd_usrdata (ABFD))
 107
 108 DEFINE_REGISTRY (bfd, GDB_BFD_DATA_ACCESSOR)
 109
 110 /* A hash table storing all the BFDs maintained in the cache.  */
 111
 112 static htab_t gdb_bfd_cache;
 113
 114 /* When true gdb will reuse an existing bfd object if the filename,
 115    modification time, and file size all match.  */
 116
 117 static int bfd_sharing = 1;
 118 static void
 119 show_bfd_sharing  (struct ui_file *file, int from_tty,
 120                    struct cmd_list_element *c, const char *value)
 121 {
 122   fprintf_filtered (file, _("BFD sharing is %s.\n"), value);
 123 }
 124
 125 /* The type of an object being looked up in gdb_bfd_cache.  We use
 126    htab's capability of storing one kind of object (BFD in this case)
 127    and using a different sort of object for searching.  */
 128
 129 struct gdb_bfd_cache_search
 130 {
 131   /* The filename.  */
 132   const char *filename;
 133   /* The mtime.  */
 134   time_t mtime;
 135   /* The file size (in bytes).  */
 136   off_t size;
 137   /* The inode of the file.  */
 138   ino_t inode;
 139   /* The device id of the file.  */
 140   dev_t device_id;
 141 };
 142
 143 /* A hash function for BFDs.  */
 144
 145 static hashval_t
 146 hash_bfd (const void *b)
 147 {
 148   const bfd *abfd = b;
 149
 150   /* It is simplest to just hash the filename.  */
 151   return htab_hash_string (bfd_get_filename (abfd));
 152 }
 153
 154 /* An equality function for BFDs.  Note that this expects the caller
 155    to search using struct gdb_bfd_cache_search only, not BFDs.  */
 156
 157 static int
 158 eq_bfd (const void *a, const void *b)
 159 {
 160   const bfd *abfd = a;
 161   const struct gdb_bfd_cache_search *s = b;
 162   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 163
 164   return (gdata->mtime == s->mtime
 165           && gdata->size == s->size
 166           && gdata->inode == s->inode
 167           && gdata->device_id == s->device_id
 168           && strcmp (bfd_get_filename (abfd), s->filename) == 0);
 169 }
 170
 171 /* See gdb_bfd.h.  */
 172
 173 int
 174 is_target_filename (const char *name)
 175 {
 176   return startswith (name, TARGET_SYSROOT_PREFIX);
 177 }
 178
 179 /* See gdb_bfd.h.  */
 180
 181 int
 182 gdb_bfd_has_target_filename (struct bfd *abfd)
 183 {
 184   return is_target_filename (bfd_get_filename (abfd));
 185 }
 186
 187
 188 /* Return the system error number corresponding to ERRNUM.  */
 189
 190 static int
 191 fileio_errno_to_host (int errnum)
 192 {
 193   switch (errnum)
 194     {
 195       case FILEIO_EPERM:
 196         return EPERM;
 197       case FILEIO_ENOENT:
 198         return ENOENT;
 199       case FILEIO_EINTR:
 200         return EINTR;
 201       case FILEIO_EIO:
 202         return EIO;
 203       case FILEIO_EBADF:
 204         return EBADF;
 205       case FILEIO_EACCES:
 206         return EACCES;
 207       case FILEIO_EFAULT:
 208         return EFAULT;
 209       case FILEIO_EBUSY:
 210         return EBUSY;
 211       case FILEIO_EEXIST:
 212         return EEXIST;
 213       case FILEIO_ENODEV:
 214         return ENODEV;
 215       case FILEIO_ENOTDIR:
 216         return ENOTDIR;
 217       case FILEIO_EISDIR:
 218         return EISDIR;
 219       case FILEIO_EINVAL:
 220         return EINVAL;
 221       case FILEIO_ENFILE:
 222         return ENFILE;
 223       case FILEIO_EMFILE:
 224         return EMFILE;
 225       case FILEIO_EFBIG:
 226         return EFBIG;
 227       case FILEIO_ENOSPC:
 228         return ENOSPC;
 229       case FILEIO_ESPIPE:
 230         return ESPIPE;
 231       case FILEIO_EROFS:
 232         return EROFS;
 233       case FILEIO_ENOSYS:
 234         return ENOSYS;
 235       case FILEIO_ENAMETOOLONG:
 236         return ENAMETOOLONG;
 237     }
 238   return -1;
 239 }
 240
 241 /* Wrapper for target_fileio_open suitable for passing as the
 242    OPEN_FUNC argument to gdb_bfd_openr_iovec.  The supplied
 243    OPEN_CLOSURE is unused.  */
 244
 245 static void *
 246 gdb_bfd_iovec_fileio_open (struct bfd *abfd, void *inferior)
 247 {
 248   const char *filename = bfd_get_filename (abfd);
 249   int fd, target_errno;
 250   int *stream;
 251
 252   gdb_assert (is_target_filename (filename));
 253
 254   fd = target_fileio_open ((struct inferior *) inferior,
 255                            filename + strlen (TARGET_SYSROOT_PREFIX),
 256                            FILEIO_O_RDONLY, 0,
 257                            &target_errno);
 258   if (fd == -1)
 259     {
 260       errno = fileio_errno_to_host (target_errno);
 261       bfd_set_error (bfd_error_system_call);
 262       return NULL;
 263     }
 264
 265   stream = XCNEW (int);
 266   *stream = fd;
 267   return stream;
 268 }
 269
 270 /* Wrapper for target_fileio_pread suitable for passing as the
 271    PREAD_FUNC argument to gdb_bfd_openr_iovec.  */
 272
 273 static file_ptr
 274 gdb_bfd_iovec_fileio_pread (struct bfd *abfd, void *stream, void *buf,
 275                             file_ptr nbytes, file_ptr offset)
 276 {
 277   int fd = *(int *) stream;
 278   int target_errno;
 279   file_ptr pos, bytes;
 280
 281   pos = 0;
 282   while (nbytes > pos)
 283     {
 284       bytes = target_fileio_pread (fd, (gdb_byte *) buf + pos,
 285                                    nbytes - pos, offset + pos,
 286                                    &target_errno);
 287       if (bytes == 0)
 288         /* Success, but no bytes, means end-of-file.  */
 289         break;
 290       if (bytes == -1)
 291         {
 292           errno = fileio_errno_to_host (target_errno);
 293           bfd_set_error (bfd_error_system_call);
 294           return -1;
 295         }
 296
 297       pos += bytes;
 298     }
 299
 300   return pos;
 301 }
 302
 303 /* Wrapper for target_fileio_close suitable for passing as the
 304    CLOSE_FUNC argument to gdb_bfd_openr_iovec.  */
 305
 306 static int
 307 gdb_bfd_iovec_fileio_close (struct bfd *abfd, void *stream)
 308 {
 309   int fd = *(int *) stream;
 310   int target_errno;
 311
 312   xfree (stream);
 313
 314   /* Ignore errors on close.  These may happen with remote
 315      targets if the connection has already been torn down.  */
 316   target_fileio_close (fd, &target_errno);
 317
 318   /* Zero means success.  */
 319   return 0;
 320 }
 321
 322 /* Wrapper for target_fileio_fstat suitable for passing as the
 323    STAT_FUNC argument to gdb_bfd_openr_iovec.  */
 324
 325 static int
 326 gdb_bfd_iovec_fileio_fstat (struct bfd *abfd, void *stream,
 327                             struct stat *sb)
 328 {
 329   int fd = *(int *) stream;
 330   int target_errno;
 331   int result;
 332
 333   result = target_fileio_fstat (fd, sb, &target_errno);
 334   if (result == -1)
 335     {
 336       errno = fileio_errno_to_host (target_errno);
 337       bfd_set_error (bfd_error_system_call);
 338     }
 339
 340   return result;
 341 }
 342
 343 /* See gdb_bfd.h.  */
 344
 345 struct bfd *
 346 gdb_bfd_open (const char *name, const char *target, int fd)
 347 {
 348   hashval_t hash;
 349   void **slot;
 350   bfd *abfd;
 351   struct gdb_bfd_cache_search search;
 352   struct stat st;
 353
 354   if (is_target_filename (name))
 355     {
 356       if (!target_filesystem_is_local ())
 357         {
 358           gdb_assert (fd == -1);
 359
 360           return gdb_bfd_openr_iovec (name, target,
 361                                       gdb_bfd_iovec_fileio_open,
 362                                       current_inferior (),
 363                                       gdb_bfd_iovec_fileio_pread,
 364                                       gdb_bfd_iovec_fileio_close,
 365                                       gdb_bfd_iovec_fileio_fstat);
 366         }
 367
 368       name += strlen (TARGET_SYSROOT_PREFIX);
 369     }
 370
 371   if (gdb_bfd_cache == NULL)
 372     gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
 373                                        xcalloc, xfree);
 374
 375   if (fd == -1)
 376     {
 377       fd = gdb_open_cloexec (name, O_RDONLY | O_BINARY, 0);
 378       if (fd == -1)
 379         {
 380           bfd_set_error (bfd_error_system_call);
 381           return NULL;
 382         }
 383     }
 384
 385   search.filename = name;
 386   if (fstat (fd, &st) < 0)
 387     {
 388       /* Weird situation here.  */
 389       search.mtime = 0;
 390       search.size = 0;
 391       search.inode = 0;
 392       search.device_id = 0;
 393     }
 394   else
 395     {
 396       search.mtime = st.st_mtime;
 397       search.size = st.st_size;
 398       search.inode = st.st_ino;
 399       search.device_id = st.st_dev;
 400     }
 401
 402   /* Note that this must compute the same result as hash_bfd.  */
 403   hash = htab_hash_string (name);
 404   /* Note that we cannot use htab_find_slot_with_hash here, because
 405      opening the BFD may fail; and this would violate hashtab
 406      invariants.  */
 407   abfd = htab_find_with_hash (gdb_bfd_cache, &search, hash);
 408   if (bfd_sharing && abfd != NULL)
 409     {
 410       close (fd);
 411       gdb_bfd_ref (abfd);
 412       return abfd;
 413     }
 414
 415   abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 416   if (abfd == NULL)
 417     return NULL;
 418
 419   if (bfd_sharing)
 420     {
 421       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
 422       gdb_assert (!*slot);
 423       *slot = abfd;
 424     }
 425
 426   gdb_bfd_ref (abfd);
 427   return abfd;
 428 }
 429
 430 /* A helper function that releases any section data attached to the
 431    BFD.  */
 432
 433 static void
 434 free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
 435 {
 436   struct gdb_bfd_section_data *sect = bfd_get_section_userdata (abfd, sectp);
 437
 438   if (sect != NULL && sect->data != NULL)
 439     {
 440 #ifdef HAVE_MMAP
 441       if (sect->map_addr != NULL)
 442         {
 443           int res;
 444
 445           res = munmap (sect->map_addr, sect->map_len);
 446           gdb_assert (res == 0);
 447         }
 448       else
 449 #endif
 450         xfree (sect->data);
 451     }
 452 }
 453
 454 /* Close ABFD, and warn if that fails.  */
 455
 456 static int
 457 gdb_bfd_close_or_warn (struct bfd *abfd)
 458 {
 459   int ret;
 460   char *name = bfd_get_filename (abfd);
 461
 462   bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
 463
 464   ret = bfd_close (abfd);
 465
 466   if (!ret)
 467     warning (_("cannot close \"%s\": %s"),
 468              name, bfd_errmsg (bfd_get_error ()));
 469
 470   return ret;
 471 }
 472
 473 /* See gdb_bfd.h.  */
 474
 475 void
 476 gdb_bfd_ref (struct bfd *abfd)
 477 {
 478   struct stat buf;
 479   struct gdb_bfd_data *gdata;
 480   void **slot;
 481
 482   if (abfd == NULL)
 483     return;
 484
 485   gdata = bfd_usrdata (abfd);
 486
 487   if (gdata != NULL)
 488     {
 489       gdata->refc += 1;
 490       return;
 491     }
 492
 493   /* Ask BFD to decompress sections in bfd_get_full_section_contents.  */
 494   abfd->flags |= BFD_DECOMPRESS;
 495
 496   gdata = bfd_zalloc (abfd, sizeof (struct gdb_bfd_data));
 497   gdata->refc = 1;
 498   gdata->mtime = bfd_get_mtime (abfd);
 499   gdata->size = bfd_get_size (abfd);
 500   gdata->archive_bfd = NULL;
 501   if (bfd_stat (abfd, &buf) == 0)
 502     {
 503       gdata->inode = buf.st_ino;
 504       gdata->device_id = buf.st_dev;
 505     }
 506   else
 507     {
 508       /* The stat failed.  */
 509       gdata->inode = 0;
 510       gdata->device_id = 0;
 511     }
 512   bfd_usrdata (abfd) = gdata;
 513
 514   bfd_alloc_data (abfd);
 515
 516   /* This is the first we've seen it, so add it to the hash table.  */
 517   slot = htab_find_slot (all_bfds, abfd, INSERT);
 518   gdb_assert (slot && !*slot);
 519   *slot = abfd;
 520 }
 521
 522 /* See gdb_bfd.h.  */
 523
 524 void
 525 gdb_bfd_unref (struct bfd *abfd)
 526 {
 527   int ix;
 528   struct gdb_bfd_data *gdata;
 529   struct gdb_bfd_cache_search search;
 530   bfd *archive_bfd, *included_bfd;
 531
 532   if (abfd == NULL)
 533     return;
 534
 535   gdata = bfd_usrdata (abfd);
 536   gdb_assert (gdata->refc >= 1);
 537
 538   gdata->refc -= 1;
 539   if (gdata->refc > 0)
 540     return;
 541
 542   archive_bfd = gdata->archive_bfd;
 543   search.filename = bfd_get_filename (abfd);
 544
 545   if (gdb_bfd_cache && search.filename)
 546     {
 547       hashval_t hash = htab_hash_string (search.filename);
 548       void **slot;
 549
 550       search.mtime = gdata->mtime;
 551       search.size = gdata->size;
 552       search.inode = gdata->inode;
 553       search.device_id = gdata->device_id;
 554       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 555                                        NO_INSERT);
 556
 557       if (slot && *slot)
 558         htab_clear_slot (gdb_bfd_cache, slot);
 559     }
 560
 561   for (ix = 0;
 562        VEC_iterate (bfdp, gdata->included_bfds, ix, included_bfd);
 563        ++ix)
 564     gdb_bfd_unref (included_bfd);
 565   VEC_free (bfdp, gdata->included_bfds);
 566
 567   bfd_free_data (abfd);
 568   bfd_usrdata (abfd) = NULL;  /* Paranoia.  */
 569
 570   htab_remove_elt (all_bfds, abfd);
 571
 572   gdb_bfd_close_or_warn (abfd);
 573
 574   gdb_bfd_unref (archive_bfd);
 575 }
 576
 577 /* A helper function that returns the section data descriptor
 578    associated with SECTION.  If no such descriptor exists, a new one
 579    is allocated and cleared.  */
 580
 581 static struct gdb_bfd_section_data *
 582 get_section_descriptor (asection *section)
 583 {
 584   struct gdb_bfd_section_data *result;
 585
 586   result = bfd_get_section_userdata (section->owner, section);
 587
 588   if (result == NULL)
 589     {
 590       result = bfd_zalloc (section->owner, sizeof (*result));
 591       bfd_set_section_userdata (section->owner, section, result);
 592     }
 593
 594   return result;
 595 }
 596
 597 /* See gdb_bfd.h.  */
 598
 599 const gdb_byte *
 600 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 601 {
 602   bfd *abfd;
 603   struct gdb_bfd_section_data *descriptor;
 604   bfd_byte *data;
 605
 606   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 607   gdb_assert (size != NULL);
 608
 609   abfd = sectp->owner;
 610
 611   descriptor = get_section_descriptor (sectp);
 612
 613   /* If the data was already read for this BFD, just reuse it.  */
 614   if (descriptor->data != NULL)
 615     goto done;
 616
 617 #ifdef HAVE_MMAP
 618   if (!bfd_is_section_compressed (abfd, sectp))
 619     {
 620       /* The page size, used when mmapping.  */
 621       static int pagesize;
 622
 623       if (pagesize == 0)
 624         pagesize = getpagesize ();
 625
 626       /* Only try to mmap sections which are large enough: we don't want
 627          to waste space due to fragmentation.  */
 628
 629       if (bfd_get_section_size (sectp) > 4 * pagesize)
 630         {
 631           descriptor->size = bfd_get_section_size (sectp);
 632           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 633                                        MAP_PRIVATE, sectp->filepos,
 634                                        &descriptor->map_addr,
 635                                        &descriptor->map_len);
 636
 637           if ((caddr_t)descriptor->data != MAP_FAILED)
 638             {
 639 #if HAVE_POSIX_MADVISE
 640               posix_madvise (descriptor->map_addr, descriptor->map_len,
 641                              POSIX_MADV_WILLNEED);
 642 #endif
 643               goto done;
 644             }
 645
 646           /* On failure, clear out the section data and try again.  */
 647           memset (descriptor, 0, sizeof (*descriptor));
 648         }
 649     }
 650 #endif /* HAVE_MMAP */
 651
 652   /* Handle compressed sections, or ordinary uncompressed sections in
 653      the no-mmap case.  */
 654
 655   descriptor->size = bfd_get_section_size (sectp);
 656   descriptor->data = NULL;
 657
 658   data = NULL;
 659   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 660     error (_("Can't read data for section '%s' in file '%s'"),
 661            bfd_get_section_name (abfd, sectp),
 662            bfd_get_filename (abfd));
 663   descriptor->data = data;
 664
 665  done:
 666   gdb_assert (descriptor->data != NULL);
 667   *size = descriptor->size;
 668   return descriptor->data;
 669 }
 670
 671 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 672    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 673    not preserved.  */
 674
 675 static int
 676 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 677 {
 678   unsigned long file_crc = 0;
 679
 680   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 681     {
 682       warning (_("Problem reading \"%s\" for CRC: %s"),
 683                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 684       return 0;
 685     }
 686
 687   for (;;)
 688     {
 689       gdb_byte buffer[8 * 1024];
 690       bfd_size_type count;
 691
 692       count = bfd_bread (buffer, sizeof (buffer), abfd);
 693       if (count == (bfd_size_type) -1)
 694         {
 695           warning (_("Problem reading \"%s\" for CRC: %s"),
 696                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 697           return 0;
 698         }
 699       if (count == 0)
 700         break;
 701       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 702     }
 703
 704   *file_crc_return = file_crc;
 705   return 1;
 706 }
 707
 708 /* See gdb_bfd.h.  */
 709
 710 int
 711 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 712 {
 713   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 714
 715   if (!gdata->crc_computed)
 716     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 717
 718   if (gdata->crc_computed)
 719     *crc_out = gdata->crc;
 720   return gdata->crc_computed;
 721 }
 722
 723 \f
 724
 725 /* See gdb_bfd.h.  */
 726
 727 bfd *
 728 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 729                int fd)
 730 {
 731   bfd *result = bfd_fopen (filename, target, mode, fd);
 732
 733   if (result)
 734     gdb_bfd_ref (result);
 735
 736   return result;
 737 }
 738
 739 /* See gdb_bfd.h.  */
 740
 741 bfd *
 742 gdb_bfd_openr (const char *filename, const char *target)
 743 {
 744   bfd *result = bfd_openr (filename, target);
 745
 746   if (result)
 747     gdb_bfd_ref (result);
 748
 749   return result;
 750 }
 751
 752 /* See gdb_bfd.h.  */
 753
 754 bfd *
 755 gdb_bfd_openw (const char *filename, const char *target)
 756 {
 757   bfd *result = bfd_openw (filename, target);
 758
 759   if (result)
 760     gdb_bfd_ref (result);
 761
 762   return result;
 763 }
 764
 765 /* See gdb_bfd.h.  */
 766
 767 bfd *
 768 gdb_bfd_openr_iovec (const char *filename, const char *target,
 769                      void *(*open_func) (struct bfd *nbfd,
 770                                          void *open_closure),
 771                      void *open_closure,
 772                      file_ptr (*pread_func) (struct bfd *nbfd,
 773                                              void *stream,
 774                                              void *buf,
 775                                              file_ptr nbytes,
 776                                              file_ptr offset),
 777                      int (*close_func) (struct bfd *nbfd,
 778                                         void *stream),
 779                      int (*stat_func) (struct bfd *abfd,
 780                                        void *stream,
 781                                        struct stat *sb))
 782 {
 783   bfd *result = bfd_openr_iovec (filename, target,
 784                                  open_func, open_closure,
 785                                  pread_func, close_func, stat_func);
 786
 787   if (result)
 788     gdb_bfd_ref (result);
 789
 790   return result;
 791 }
 792
 793 /* See gdb_bfd.h.  */
 794
 795 void
 796 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 797 {
 798   struct gdb_bfd_data *gdata;
 799
 800   gdb_bfd_ref (child);
 801   /* No need to stash the filename here, because we also keep a
 802      reference on the parent archive.  */
 803
 804   gdata = bfd_usrdata (child);
 805   if (gdata->archive_bfd == NULL)
 806     {
 807       gdata->archive_bfd = parent;
 808       gdb_bfd_ref (parent);
 809     }
 810   else
 811     gdb_assert (gdata->archive_bfd == parent);
 812 }
 813
 814 /* See gdb_bfd.h.  */
 815
 816 bfd *
 817 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 818 {
 819   bfd *result = bfd_openr_next_archived_file (archive, previous);
 820
 821   if (result)
 822     gdb_bfd_mark_parent (result, archive);
 823
 824   return result;
 825 }
 826
 827 /* See gdb_bfd.h.  */
 828
 829 void
 830 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
 831 {
 832   struct gdb_bfd_data *gdata;
 833
 834   gdb_bfd_ref (includee);
 835   gdata = bfd_usrdata (includer);
 836   VEC_safe_push (bfdp, gdata->included_bfds, includee);
 837 }
 838
 839 /* See gdb_bfd.h.  */
 840
 841 bfd *
 842 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
 843 {
 844   bfd *result = bfd_fdopenr (filename, target, fd);
 845
 846   if (result)
 847     gdb_bfd_ref (result);
 848
 849   return result;
 850 }
 851
 852 \f
 853
 854 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
 855
 856 /* See gdb_bfd.h.  */
 857
 858 int
 859 gdb_bfd_section_index (bfd *abfd, asection *section)
 860 {
 861   if (section == NULL)
 862     return -1;
 863   else if (section == bfd_com_section_ptr)
 864     return bfd_count_sections (abfd);
 865   else if (section == bfd_und_section_ptr)
 866     return bfd_count_sections (abfd) + 1;
 867   else if (section == bfd_abs_section_ptr)
 868     return bfd_count_sections (abfd) + 2;
 869   else if (section == bfd_ind_section_ptr)
 870     return bfd_count_sections (abfd) + 3;
 871   return section->index;
 872 }
 873
 874 /* See gdb_bfd.h.  */
 875
 876 int
 877 gdb_bfd_count_sections (bfd *abfd)
 878 {
 879   return bfd_count_sections (abfd) + 4;
 880 }
 881
 882 /* See gdb_bfd.h.  */
 883
 884 int
 885 gdb_bfd_requires_relocations (bfd *abfd)
 886 {
 887   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 888
 889   if (gdata->relocation_computed == 0)
 890     {
 891       asection *sect;
 892
 893       for (sect = abfd->sections; sect != NULL; sect = sect->next)
 894         if ((sect->flags & SEC_RELOC) != 0)
 895           {
 896             gdata->needs_relocations = 1;
 897             break;
 898           }
 899
 900       gdata->relocation_computed = 1;
 901     }
 902
 903   return gdata->needs_relocations;
 904 }
 905
 906 \f
 907
 908 /* A callback for htab_traverse that prints a single BFD.  */
 909
 910 static int
 911 print_one_bfd (void **slot, void *data)
 912 {
 913   bfd *abfd = *slot;
 914   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 915   struct ui_out *uiout = data;
 916   struct cleanup *inner;
 917
 918   inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 919   ui_out_field_int (uiout, "refcount", gdata->refc);
 920   ui_out_field_string (uiout, "addr", host_address_to_string (abfd));
 921   ui_out_field_string (uiout, "filename", bfd_get_filename (abfd));
 922   ui_out_text (uiout, "\n");
 923   do_cleanups (inner);
 924
 925   return 1;
 926 }
 927
 928 /* Implement the 'maint info bfd' command.  */
 929
 930 static void
 931 maintenance_info_bfds (char *arg, int from_tty)
 932 {
 933   struct cleanup *cleanup;
 934   struct ui_out *uiout = current_uiout;
 935
 936   cleanup = make_cleanup_ui_out_table_begin_end (uiout, 3, -1, "bfds");
 937   ui_out_table_header (uiout, 10, ui_left, "refcount", "Refcount");
 938   ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
 939   ui_out_table_header (uiout, 40, ui_left, "filename", "Filename");
 940
 941   ui_out_table_body (uiout);
 942   htab_traverse (all_bfds, print_one_bfd, uiout);
 943
 944   do_cleanups (cleanup);
 945 }
 946
 947 /* -Wmissing-prototypes */
 948 extern initialize_file_ftype _initialize_gdb_bfd;
 949
 950 void
 951 _initialize_gdb_bfd (void)
 952 {
 953   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
 954                                 NULL, xcalloc, xfree);
 955
 956   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
 957 List the BFDs that are currently open."),
 958            &maintenanceinfolist);
 959
 960   add_setshow_boolean_cmd ("bfd-sharing", no_class,
 961                            &bfd_sharing, _("\
 962 Set whether gdb will share bfds that appear to be the same file."), _("\
 963 Show whether gdb will share bfds that appear to be the same file."), _("\
 964 When enabled gdb will reuse existing bfds rather than reopening the\n\
 965 same file.  To decide if two files are the same then gdb compares the\n\
 966 filename, file size, file modification time, and file inode."),
 967                            NULL,
 968                            &show_bfd_sharing,
 969                            &maintenance_set_cmdlist,
 970                            &maintenance_show_cmdlist);
 971 }