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