gdb/gdb_bfd.c

   1 /* Definitions for BFD wrappers used by GDB.
   2
   3    Copyright (C) 2011-2013 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 "gdb_assert.h"
  23 #include "gdb_string.h"
  24 #include "ui-out.h"
  25 #include "gdbcmd.h"
  26 #include "hashtab.h"
  27 #ifdef HAVE_ZLIB_H
  28 #include <zlib.h>
  29 #endif
  30 #ifdef HAVE_MMAP
  31 #include <sys/mman.h>
  32 #ifndef MAP_FAILED
  33 #define MAP_FAILED ((void *) -1)
  34 #endif
  35 #endif
  36
  37 /* An object of this type is stored in the section's user data when
  38    mapping a section.  */
  39
  40 struct gdb_bfd_section_data
  41 {
  42   /* Size of the data.  */
  43   bfd_size_type size;
  44   /* If the data was mmapped, this is the length of the map.  */
  45   bfd_size_type map_len;
  46   /* The data.  If NULL, the section data has not been read.  */
  47   void *data;
  48   /* If the data was mmapped, this is the map address.  */
  49   void *map_addr;
  50 };
  51
  52 /* A hash table holding every BFD that gdb knows about.  This is not
  53    to be confused with 'gdb_bfd_cache', which is used for sharing
  54    BFDs; in contrast, this hash is used just to implement
  55    "maint info bfd".  */
  56
  57 static htab_t all_bfds;
  58
  59 /* See gdb_bfd.h.  */
  60
  61 void
  62 gdb_bfd_stash_filename (struct bfd *abfd)
  63 {
  64   char *name = bfd_get_filename (abfd);
  65   char *data;
  66
  67   data = bfd_alloc (abfd, strlen (name) + 1);
  68   strcpy (data, name);
  69
  70   /* Unwarranted chumminess with BFD.  */
  71   abfd->filename = data;
  72 }
  73
  74 /* An object of this type is stored in each BFD's user data.  */
  75
  76 struct gdb_bfd_data
  77 {
  78   /* The reference count.  */
  79   int refc;
  80
  81   /* The mtime of the BFD at the point the cache entry was made.  */
  82   time_t mtime;
  83
  84   /* This is true if we have successfully computed the file's CRC.  */
  85   unsigned int crc_computed : 1;
  86
  87   /* The file's CRC.  */
  88   unsigned long crc;
  89
  90   /* If the BFD comes from an archive, this points to the archive's
  91      BFD.  Otherwise, this is NULL.  */
  92   bfd *archive_bfd;
  93
  94   /* The registry.  */
  95   REGISTRY_FIELDS;
  96 };
  97
  98 #define GDB_BFD_DATA_ACCESSOR(ABFD) \
  99   ((struct gdb_bfd_data *) bfd_usrdata (ABFD))
 100
 101 DEFINE_REGISTRY (bfd, GDB_BFD_DATA_ACCESSOR)
 102
 103 /* A hash table storing all the BFDs maintained in the cache.  */
 104
 105 static htab_t gdb_bfd_cache;
 106
 107 /* The type of an object being looked up in gdb_bfd_cache.  We use
 108    htab's capability of storing one kind of object (BFD in this case)
 109    and using a different sort of object for searching.  */
 110
 111 struct gdb_bfd_cache_search
 112 {
 113   /* The filename.  */
 114   const char *filename;
 115   /* The mtime.  */
 116   time_t mtime;
 117 };
 118
 119 /* A hash function for BFDs.  */
 120
 121 static hashval_t
 122 hash_bfd (const void *b)
 123 {
 124   const bfd *abfd = b;
 125
 126   /* It is simplest to just hash the filename.  */
 127   return htab_hash_string (bfd_get_filename (abfd));
 128 }
 129
 130 /* An equality function for BFDs.  Note that this expects the caller
 131    to search using struct gdb_bfd_cache_search only, not BFDs.  */
 132
 133 static int
 134 eq_bfd (const void *a, const void *b)
 135 {
 136   const bfd *abfd = a;
 137   const struct gdb_bfd_cache_search *s = b;
 138   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 139
 140   return (gdata->mtime == s->mtime
 141           && strcmp (bfd_get_filename (abfd), s->filename) == 0);
 142 }
 143
 144 /* See gdb_bfd.h.  */
 145
 146 struct bfd *
 147 gdb_bfd_open (const char *name, const char *target, int fd)
 148 {
 149   hashval_t hash;
 150   void **slot;
 151   bfd *abfd;
 152   struct gdb_bfd_cache_search search;
 153   struct stat st;
 154
 155   if (gdb_bfd_cache == NULL)
 156     gdb_bfd_cache = htab_create_alloc (1, hash_bfd, eq_bfd, NULL,
 157                                        xcalloc, xfree);
 158
 159   if (fd == -1)
 160     {
 161       fd = open (name, O_RDONLY | O_BINARY);
 162       if (fd == -1)
 163         {
 164           bfd_set_error (bfd_error_system_call);
 165           return NULL;
 166         }
 167     }
 168
 169   search.filename = name;
 170   if (fstat (fd, &st) < 0)
 171     {
 172       /* Weird situation here.  */
 173       search.mtime = 0;
 174     }
 175   else
 176     search.mtime = st.st_mtime;
 177
 178   /* Note that this must compute the same result as hash_bfd.  */
 179   hash = htab_hash_string (name);
 180   /* Note that we cannot use htab_find_slot_with_hash here, because
 181      opening the BFD may fail; and this would violate hashtab
 182      invariants.  */
 183   abfd = htab_find_with_hash (gdb_bfd_cache, &search, hash);
 184   if (abfd != NULL)
 185     {
 186       close (fd);
 187       gdb_bfd_ref (abfd);
 188       return abfd;
 189     }
 190
 191   abfd = bfd_fopen (name, target, FOPEN_RB, fd);
 192   if (abfd == NULL)
 193     return NULL;
 194
 195   slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash, INSERT);
 196   gdb_assert (!*slot);
 197   *slot = abfd;
 198
 199   gdb_bfd_stash_filename (abfd);
 200   gdb_bfd_ref (abfd);
 201   return abfd;
 202 }
 203
 204 /* A helper function that releases any section data attached to the
 205    BFD.  */
 206
 207 static void
 208 free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
 209 {
 210   struct gdb_bfd_section_data *sect = bfd_get_section_userdata (abfd, sectp);
 211
 212   if (sect != NULL && sect->data != NULL)
 213     {
 214 #ifdef HAVE_MMAP
 215       if (sect->map_addr != NULL)
 216         {
 217           int res;
 218
 219           res = munmap (sect->map_addr, sect->map_len);
 220           gdb_assert (res == 0);
 221         }
 222       else
 223 #endif
 224         xfree (sect->data);
 225     }
 226 }
 227
 228 /* Close ABFD, and warn if that fails.  */
 229
 230 static int
 231 gdb_bfd_close_or_warn (struct bfd *abfd)
 232 {
 233   int ret;
 234   char *name = bfd_get_filename (abfd);
 235
 236   bfd_map_over_sections (abfd, free_one_bfd_section, NULL);
 237
 238   ret = bfd_close (abfd);
 239
 240   if (!ret)
 241     warning (_("cannot close \"%s\": %s"),
 242              name, bfd_errmsg (bfd_get_error ()));
 243
 244   return ret;
 245 }
 246
 247 /* See gdb_bfd.h.  */
 248
 249 void
 250 gdb_bfd_ref (struct bfd *abfd)
 251 {
 252   struct gdb_bfd_data *gdata;
 253   void **slot;
 254
 255   if (abfd == NULL)
 256     return;
 257
 258   gdata = bfd_usrdata (abfd);
 259
 260   if (gdata != NULL)
 261     {
 262       gdata->refc += 1;
 263       return;
 264     }
 265
 266   /* Ask BFD to decompress sections in bfd_get_full_section_contents.  */
 267   abfd->flags |= BFD_DECOMPRESS;
 268
 269   gdata = bfd_zalloc (abfd, sizeof (struct gdb_bfd_data));
 270   gdata->refc = 1;
 271   gdata->mtime = bfd_get_mtime (abfd);
 272   gdata->archive_bfd = NULL;
 273   bfd_usrdata (abfd) = gdata;
 274
 275   bfd_alloc_data (abfd);
 276
 277   /* This is the first we've seen it, so add it to the hash table.  */
 278   slot = htab_find_slot (all_bfds, abfd, INSERT);
 279   gdb_assert (slot && !*slot);
 280   *slot = abfd;
 281 }
 282
 283 /* See gdb_bfd.h.  */
 284
 285 void
 286 gdb_bfd_unref (struct bfd *abfd)
 287 {
 288   struct gdb_bfd_data *gdata;
 289   struct gdb_bfd_cache_search search;
 290   bfd *archive_bfd;
 291
 292   if (abfd == NULL)
 293     return;
 294
 295   gdata = bfd_usrdata (abfd);
 296   gdb_assert (gdata->refc >= 1);
 297
 298   gdata->refc -= 1;
 299   if (gdata->refc > 0)
 300     return;
 301
 302   archive_bfd = gdata->archive_bfd;
 303   search.filename = bfd_get_filename (abfd);
 304
 305   if (gdb_bfd_cache && search.filename)
 306     {
 307       hashval_t hash = htab_hash_string (search.filename);
 308       void **slot;
 309
 310       search.mtime = gdata->mtime;
 311       slot = htab_find_slot_with_hash (gdb_bfd_cache, &search, hash,
 312                                        NO_INSERT);
 313
 314       if (slot && *slot)
 315         htab_clear_slot (gdb_bfd_cache, slot);
 316     }
 317
 318   bfd_free_data (abfd);
 319   bfd_usrdata (abfd) = NULL;  /* Paranoia.  */
 320
 321   htab_remove_elt (all_bfds, abfd);
 322
 323   gdb_bfd_close_or_warn (abfd);
 324
 325   gdb_bfd_unref (archive_bfd);
 326 }
 327
 328 /* A helper function that returns the section data descriptor
 329    associated with SECTION.  If no such descriptor exists, a new one
 330    is allocated and cleared.  */
 331
 332 static struct gdb_bfd_section_data *
 333 get_section_descriptor (asection *section)
 334 {
 335   struct gdb_bfd_section_data *result;
 336
 337   result = bfd_get_section_userdata (section->owner, section);
 338
 339   if (result == NULL)
 340     {
 341       result = bfd_zalloc (section->owner, sizeof (*result));
 342       bfd_set_section_userdata (section->owner, section, result);
 343     }
 344
 345   return result;
 346 }
 347
 348 /* See gdb_bfd.h.  */
 349
 350 const gdb_byte *
 351 gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
 352 {
 353   bfd *abfd;
 354   struct gdb_bfd_section_data *descriptor;
 355   bfd_byte *data;
 356
 357   gdb_assert ((sectp->flags & SEC_RELOC) == 0);
 358   gdb_assert (size != NULL);
 359
 360   abfd = sectp->owner;
 361
 362   descriptor = get_section_descriptor (sectp);
 363
 364   /* If the data was already read for this BFD, just reuse it.  */
 365   if (descriptor->data != NULL)
 366     goto done;
 367
 368 #ifdef HAVE_MMAP
 369   if (!bfd_is_section_compressed (abfd, sectp))
 370     {
 371       /* The page size, used when mmapping.  */
 372       static int pagesize;
 373
 374       if (pagesize == 0)
 375         pagesize = getpagesize ();
 376
 377       /* Only try to mmap sections which are large enough: we don't want
 378          to waste space due to fragmentation.  */
 379
 380       if (bfd_get_section_size (sectp) > 4 * pagesize)
 381         {
 382           descriptor->size = bfd_get_section_size (sectp);
 383           descriptor->data = bfd_mmap (abfd, 0, descriptor->size, PROT_READ,
 384                                        MAP_PRIVATE, sectp->filepos,
 385                                        &descriptor->map_addr,
 386                                        &descriptor->map_len);
 387
 388           if ((caddr_t)descriptor->data != MAP_FAILED)
 389             {
 390 #if HAVE_POSIX_MADVISE
 391               posix_madvise (descriptor->map_addr, descriptor->map_len,
 392                              POSIX_MADV_WILLNEED);
 393 #endif
 394               goto done;
 395             }
 396
 397           /* On failure, clear out the section data and try again.  */
 398           memset (descriptor, 0, sizeof (*descriptor));
 399         }
 400     }
 401 #endif /* HAVE_MMAP */
 402
 403   /* Handle compressed sections, or ordinary uncompressed sections in
 404      the no-mmap case.  */
 405
 406   descriptor->size = bfd_get_section_size (sectp);
 407   descriptor->data = NULL;
 408
 409   data = NULL;
 410   if (!bfd_get_full_section_contents (abfd, sectp, &data))
 411     error (_("Can't read data for section '%s' in file '%s'"),
 412            bfd_get_section_name (abfd, sectp),
 413            bfd_get_filename (abfd));
 414   descriptor->data = data;
 415
 416  done:
 417   gdb_assert (descriptor->data != NULL);
 418   *size = descriptor->size;
 419   return descriptor->data;
 420 }
 421
 422 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
 423    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
 424    not preserved.  */
 425
 426 static int
 427 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 428 {
 429   unsigned long file_crc = 0;
 430
 431   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 432     {
 433       warning (_("Problem reading \"%s\" for CRC: %s"),
 434                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 435       return 0;
 436     }
 437
 438   for (;;)
 439     {
 440       gdb_byte buffer[8 * 1024];
 441       bfd_size_type count;
 442
 443       count = bfd_bread (buffer, sizeof (buffer), abfd);
 444       if (count == (bfd_size_type) -1)
 445         {
 446           warning (_("Problem reading \"%s\" for CRC: %s"),
 447                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
 448           return 0;
 449         }
 450       if (count == 0)
 451         break;
 452       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
 453     }
 454
 455   *file_crc_return = file_crc;
 456   return 1;
 457 }
 458
 459 /* See gdb_bfd.h.  */
 460
 461 int
 462 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
 463 {
 464   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 465
 466   if (!gdata->crc_computed)
 467     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
 468
 469   if (gdata->crc_computed)
 470     *crc_out = gdata->crc;
 471   return gdata->crc_computed;
 472 }
 473
 474 \f
 475
 476 /* See gdb_bfd.h.  */
 477
 478 bfd *
 479 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
 480                int fd)
 481 {
 482   bfd *result = bfd_fopen (filename, target, mode, fd);
 483
 484   if (result)
 485     {
 486       gdb_bfd_stash_filename (result);
 487       gdb_bfd_ref (result);
 488     }
 489
 490   return result;
 491 }
 492
 493 /* See gdb_bfd.h.  */
 494
 495 bfd *
 496 gdb_bfd_openr (const char *filename, const char *target)
 497 {
 498   bfd *result = bfd_openr (filename, target);
 499
 500   if (result)
 501     {
 502       gdb_bfd_stash_filename (result);
 503       gdb_bfd_ref (result);
 504     }
 505
 506   return result;
 507 }
 508
 509 /* See gdb_bfd.h.  */
 510
 511 bfd *
 512 gdb_bfd_openw (const char *filename, const char *target)
 513 {
 514   bfd *result = bfd_openw (filename, target);
 515
 516   if (result)
 517     {
 518       gdb_bfd_stash_filename (result);
 519       gdb_bfd_ref (result);
 520     }
 521
 522   return result;
 523 }
 524
 525 /* See gdb_bfd.h.  */
 526
 527 bfd *
 528 gdb_bfd_openr_iovec (const char *filename, const char *target,
 529                      void *(*open_func) (struct bfd *nbfd,
 530                                          void *open_closure),
 531                      void *open_closure,
 532                      file_ptr (*pread_func) (struct bfd *nbfd,
 533                                              void *stream,
 534                                              void *buf,
 535                                              file_ptr nbytes,
 536                                              file_ptr offset),
 537                      int (*close_func) (struct bfd *nbfd,
 538                                         void *stream),
 539                      int (*stat_func) (struct bfd *abfd,
 540                                        void *stream,
 541                                        struct stat *sb))
 542 {
 543   bfd *result = bfd_openr_iovec (filename, target,
 544                                  open_func, open_closure,
 545                                  pread_func, close_func, stat_func);
 546
 547   if (result)
 548     {
 549       gdb_bfd_ref (result);
 550       gdb_bfd_stash_filename (result);
 551     }
 552
 553   return result;
 554 }
 555
 556 /* See gdb_bfd.h.  */
 557
 558 void
 559 gdb_bfd_mark_parent (bfd *child, bfd *parent)
 560 {
 561   struct gdb_bfd_data *gdata;
 562
 563   gdb_bfd_ref (child);
 564   /* No need to stash the filename here, because we also keep a
 565      reference on the parent archive.  */
 566
 567   gdata = bfd_usrdata (child);
 568   if (gdata->archive_bfd == NULL)
 569     {
 570       gdata->archive_bfd = parent;
 571       gdb_bfd_ref (parent);
 572     }
 573   else
 574     gdb_assert (gdata->archive_bfd == parent);
 575 }
 576
 577 /* See gdb_bfd.h.  */
 578
 579 bfd *
 580 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
 581 {
 582   bfd *result = bfd_openr_next_archived_file (archive, previous);
 583
 584   if (result)
 585     gdb_bfd_mark_parent (result, archive);
 586
 587   return result;
 588 }
 589
 590 /* See gdb_bfd.h.  */
 591
 592 bfd *
 593 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
 594 {
 595   bfd *result = bfd_fdopenr (filename, target, fd);
 596
 597   if (result)
 598     {
 599       gdb_bfd_ref (result);
 600       gdb_bfd_stash_filename (result);
 601     }
 602
 603   return result;
 604 }
 605
 606 \f
 607
 608 /* A callback for htab_traverse that prints a single BFD.  */
 609
 610 static int
 611 print_one_bfd (void **slot, void *data)
 612 {
 613   bfd *abfd = *slot;
 614   struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
 615   struct ui_out *uiout = data;
 616   struct cleanup *inner;
 617
 618   inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 619   ui_out_field_int (uiout, "refcount", gdata->refc);
 620   ui_out_field_string (uiout, "addr", host_address_to_string (abfd));
 621   ui_out_field_string (uiout, "filename", bfd_get_filename (abfd));
 622   ui_out_text (uiout, "\n");
 623   do_cleanups (inner);
 624
 625   return 1;
 626 }
 627
 628 /* Implement the 'maint info bfd' command.  */
 629
 630 static void
 631 maintenance_info_bfds (char *arg, int from_tty)
 632 {
 633   struct cleanup *cleanup;
 634   struct ui_out *uiout = current_uiout;
 635
 636   cleanup = make_cleanup_ui_out_table_begin_end (uiout, 3, -1, "bfds");
 637   ui_out_table_header (uiout, 10, ui_left, "refcount", "Refcount");
 638   ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
 639   ui_out_table_header (uiout, 40, ui_left, "filename", "Filename");
 640
 641   ui_out_table_body (uiout);
 642   htab_traverse (all_bfds, print_one_bfd, uiout);
 643
 644   do_cleanups (cleanup);
 645 }
 646
 647 /* -Wmissing-prototypes */
 648 extern initialize_file_ftype _initialize_gdb_bfd;
 649
 650 void
 651 _initialize_gdb_bfd (void)
 652 {
 653   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
 654                                 NULL, xcalloc, xfree);
 655
 656   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
 657 List the BFDs that are currently open."),
 658            &maintenanceinfolist);
 659 }