Automatic date update in version.in
[external/binutils.git] / gdb / gdb_bfd.c
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 gdb_bfd_ref_ptr::new_reference (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 gdb_bfd_ref_ptr::new_reference (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     {
706       warning (_("Can't read data for section '%s' in file '%s'"),
707                bfd_get_section_name (abfd, sectp),
708                bfd_get_filename (abfd));
709       /* Set size to 0 to prevent further attempts to read the invalid
710          section.  */
711       *size = 0;
712       return (const gdb_byte *) NULL;
713     }
714   descriptor->data = data;
715
716  done:
717   gdb_assert (descriptor->data != NULL);
718   *size = descriptor->size;
719   return (const gdb_byte *) descriptor->data;
720 }
721
722 /* Return 32-bit CRC for ABFD.  If successful store it to *FILE_CRC_RETURN and
723    return 1.  Otherwise print a warning and return 0.  ABFD seek position is
724    not preserved.  */
725
726 static int
727 get_file_crc (bfd *abfd, unsigned long *file_crc_return)
728 {
729   unsigned long file_crc = 0;
730
731   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
732     {
733       warning (_("Problem reading \"%s\" for CRC: %s"),
734                bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
735       return 0;
736     }
737
738   for (;;)
739     {
740       gdb_byte buffer[8 * 1024];
741       bfd_size_type count;
742
743       count = bfd_bread (buffer, sizeof (buffer), abfd);
744       if (count == (bfd_size_type) -1)
745         {
746           warning (_("Problem reading \"%s\" for CRC: %s"),
747                    bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
748           return 0;
749         }
750       if (count == 0)
751         break;
752       file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
753     }
754
755   *file_crc_return = file_crc;
756   return 1;
757 }
758
759 /* See gdb_bfd.h.  */
760
761 int
762 gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
763 {
764   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
765
766   if (!gdata->crc_computed)
767     gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
768
769   if (gdata->crc_computed)
770     *crc_out = gdata->crc;
771   return gdata->crc_computed;
772 }
773
774 \f
775
776 /* See gdb_bfd.h.  */
777
778 gdb_bfd_ref_ptr
779 gdb_bfd_fopen (const char *filename, const char *target, const char *mode,
780                int fd)
781 {
782   bfd *result = bfd_fopen (filename, target, mode, fd);
783
784   return gdb_bfd_ref_ptr::new_reference (result);
785 }
786
787 /* See gdb_bfd.h.  */
788
789 gdb_bfd_ref_ptr
790 gdb_bfd_openr (const char *filename, const char *target)
791 {
792   bfd *result = bfd_openr (filename, target);
793
794   return gdb_bfd_ref_ptr::new_reference (result);
795 }
796
797 /* See gdb_bfd.h.  */
798
799 gdb_bfd_ref_ptr
800 gdb_bfd_openw (const char *filename, const char *target)
801 {
802   bfd *result = bfd_openw (filename, target);
803
804   return gdb_bfd_ref_ptr::new_reference (result);
805 }
806
807 /* See gdb_bfd.h.  */
808
809 gdb_bfd_ref_ptr
810 gdb_bfd_openr_iovec (const char *filename, const char *target,
811                      void *(*open_func) (struct bfd *nbfd,
812                                          void *open_closure),
813                      void *open_closure,
814                      file_ptr (*pread_func) (struct bfd *nbfd,
815                                              void *stream,
816                                              void *buf,
817                                              file_ptr nbytes,
818                                              file_ptr offset),
819                      int (*close_func) (struct bfd *nbfd,
820                                         void *stream),
821                      int (*stat_func) (struct bfd *abfd,
822                                        void *stream,
823                                        struct stat *sb))
824 {
825   bfd *result = bfd_openr_iovec (filename, target,
826                                  open_func, open_closure,
827                                  pread_func, close_func, stat_func);
828
829   return gdb_bfd_ref_ptr::new_reference (result);
830 }
831
832 /* See gdb_bfd.h.  */
833
834 void
835 gdb_bfd_mark_parent (bfd *child, bfd *parent)
836 {
837   struct gdb_bfd_data *gdata;
838
839   gdb_bfd_ref (child);
840   /* No need to stash the filename here, because we also keep a
841      reference on the parent archive.  */
842
843   gdata = (struct gdb_bfd_data *) bfd_usrdata (child);
844   if (gdata->archive_bfd == NULL)
845     {
846       gdata->archive_bfd = parent;
847       gdb_bfd_ref (parent);
848     }
849   else
850     gdb_assert (gdata->archive_bfd == parent);
851 }
852
853 /* See gdb_bfd.h.  */
854
855 gdb_bfd_ref_ptr
856 gdb_bfd_openr_next_archived_file (bfd *archive, bfd *previous)
857 {
858   bfd *result = bfd_openr_next_archived_file (archive, previous);
859
860   if (result)
861     gdb_bfd_mark_parent (result, archive);
862
863   return gdb_bfd_ref_ptr (result);
864 }
865
866 /* See gdb_bfd.h.  */
867
868 void
869 gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
870 {
871   struct gdb_bfd_data *gdata;
872
873   gdata = (struct gdb_bfd_data *) bfd_usrdata (includer);
874   gdata->included_bfds.push_back (gdb_bfd_ref_ptr::new_reference (includee));
875 }
876
877 /* See gdb_bfd.h.  */
878
879 gdb_bfd_ref_ptr
880 gdb_bfd_fdopenr (const char *filename, const char *target, int fd)
881 {
882   bfd *result = bfd_fdopenr (filename, target, fd);
883
884   return gdb_bfd_ref_ptr::new_reference (result);
885 }
886
887 \f
888
889 gdb_static_assert (ARRAY_SIZE (_bfd_std_section) == 4);
890
891 /* See gdb_bfd.h.  */
892
893 int
894 gdb_bfd_section_index (bfd *abfd, asection *section)
895 {
896   if (section == NULL)
897     return -1;
898   else if (section == bfd_com_section_ptr)
899     return bfd_count_sections (abfd);
900   else if (section == bfd_und_section_ptr)
901     return bfd_count_sections (abfd) + 1;
902   else if (section == bfd_abs_section_ptr)
903     return bfd_count_sections (abfd) + 2;
904   else if (section == bfd_ind_section_ptr)
905     return bfd_count_sections (abfd) + 3;
906   return section->index;
907 }
908
909 /* See gdb_bfd.h.  */
910
911 int
912 gdb_bfd_count_sections (bfd *abfd)
913 {
914   return bfd_count_sections (abfd) + 4;
915 }
916
917 /* See gdb_bfd.h.  */
918
919 int
920 gdb_bfd_requires_relocations (bfd *abfd)
921 {
922   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
923
924   if (gdata->relocation_computed == 0)
925     {
926       asection *sect;
927
928       for (sect = abfd->sections; sect != NULL; sect = sect->next)
929         if ((sect->flags & SEC_RELOC) != 0)
930           {
931             gdata->needs_relocations = 1;
932             break;
933           }
934
935       gdata->relocation_computed = 1;
936     }
937
938   return gdata->needs_relocations;
939 }
940
941 \f
942
943 /* A callback for htab_traverse that prints a single BFD.  */
944
945 static int
946 print_one_bfd (void **slot, void *data)
947 {
948   bfd *abfd = (struct bfd *) *slot;
949   struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
950   struct ui_out *uiout = (struct ui_out *) data;
951
952   ui_out_emit_tuple tuple_emitter (uiout, NULL);
953   uiout->field_int ("refcount", gdata->refc);
954   uiout->field_string ("addr", host_address_to_string (abfd));
955   uiout->field_string ("filename", bfd_get_filename (abfd));
956   uiout->text ("\n");
957
958   return 1;
959 }
960
961 /* Implement the 'maint info bfd' command.  */
962
963 static void
964 maintenance_info_bfds (const char *arg, int from_tty)
965 {
966   struct ui_out *uiout = current_uiout;
967
968   ui_out_emit_table table_emitter (uiout, 3, -1, "bfds");
969   uiout->table_header (10, ui_left, "refcount", "Refcount");
970   uiout->table_header (18, ui_left, "addr", "Address");
971   uiout->table_header (40, ui_left, "filename", "Filename");
972
973   uiout->table_body ();
974   htab_traverse (all_bfds, print_one_bfd, uiout);
975 }
976
977 void
978 _initialize_gdb_bfd (void)
979 {
980   all_bfds = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
981                                 NULL, xcalloc, xfree);
982
983   add_cmd ("bfds", class_maintenance, maintenance_info_bfds, _("\
984 List the BFDs that are currently open."),
985            &maintenanceinfolist);
986
987   add_setshow_boolean_cmd ("bfd-sharing", no_class,
988                            &bfd_sharing, _("\
989 Set whether gdb will share bfds that appear to be the same file."), _("\
990 Show whether gdb will share bfds that appear to be the same file."), _("\
991 When enabled gdb will reuse existing bfds rather than reopening the\n\
992 same file.  To decide if two files are the same then gdb compares the\n\
993 filename, file size, file modification time, and file inode."),
994                            NULL,
995                            &show_bfd_sharing,
996                            &maintenance_set_cmdlist,
997                            &maintenance_show_cmdlist);
998
999   add_setshow_zuinteger_cmd ("bfd-cache", class_maintenance,
1000                              &debug_bfd_cache, _("\
1001 Set bfd cache debugging."), _("\
1002 Show bfd cache debugging."), _("\
1003 When non-zero, bfd cache specific debugging is enabled."),
1004                              NULL,
1005                              &show_bfd_cache_debug,
1006                              &setdebuglist, &showdebuglist);
1007 }