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