GDB (xrefs)

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