gdb/gdb_bfd.c

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