Automatic date update in version.in
[external/binutils.git] / gdb / objfiles.c
1 /* GDB routines for manipulating objfiles.
2
3    Copyright (C) 1992-2019 Free Software Foundation, Inc.
4
5    Contributed by Cygnus Support, using pieces from other GDB modules.
6
7    This file is part of GDB.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
22 /* This file contains support routines for creating, manipulating, and
23    destroying objfile structures.  */
24
25 #include "defs.h"
26 #include "bfd.h"                /* Binary File Description */
27 #include "symtab.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "gdb-stabs.h"
31 #include "target.h"
32 #include "bcache.h"
33 #include "expression.h"
34 #include "parser-defs.h"
35
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <fcntl.h>
39 #include "gdb_obstack.h"
40 #include "hashtab.h"
41
42 #include "breakpoint.h"
43 #include "block.h"
44 #include "dictionary.h"
45 #include "source.h"
46 #include "addrmap.h"
47 #include "arch-utils.h"
48 #include "exec.h"
49 #include "observable.h"
50 #include "complaints.h"
51 #include "psymtab.h"
52 #include "solist.h"
53 #include "gdb_bfd.h"
54 #include "btrace.h"
55 #include "common/pathstuff.h"
56
57 #include <vector>
58
59 /* Keep a registry of per-objfile data-pointers required by other GDB
60    modules.  */
61
62 DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
63
64 /* Externally visible variables that are owned by this module.
65    See declarations in objfile.h for more info.  */
66
67 struct objfile_pspace_info
68 {
69   struct obj_section **sections;
70   int num_sections;
71
72   /* Nonzero if object files have been added since the section map
73      was last updated.  */
74   int new_objfiles_available;
75
76   /* Nonzero if the section map MUST be updated before use.  */
77   int section_map_dirty;
78
79   /* Nonzero if section map updates should be inhibited if possible.  */
80   int inhibit_updates;
81 };
82
83 /* Per-program-space data key.  */
84 static const struct program_space_data *objfiles_pspace_data;
85
86 static void
87 objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
88 {
89   struct objfile_pspace_info *info = (struct objfile_pspace_info *) arg;
90
91   xfree (info->sections);
92   xfree (info);
93 }
94
95 /* Get the current svr4 data.  If none is found yet, add it now.  This
96    function always returns a valid object.  */
97
98 static struct objfile_pspace_info *
99 get_objfile_pspace_data (struct program_space *pspace)
100 {
101   struct objfile_pspace_info *info;
102
103   info = ((struct objfile_pspace_info *)
104           program_space_data (pspace, objfiles_pspace_data));
105   if (info == NULL)
106     {
107       info = XCNEW (struct objfile_pspace_info);
108       set_program_space_data (pspace, objfiles_pspace_data, info);
109     }
110
111   return info;
112 }
113
114 \f
115
116 /* Per-BFD data key.  */
117
118 static const struct bfd_data *objfiles_bfd_data;
119
120 /* Create the per-BFD storage object for OBJFILE.  If ABFD is not
121    NULL, and it already has a per-BFD storage object, use that.
122    Otherwise, allocate a new per-BFD storage object.  If ABFD is not
123    NULL, the object is allocated on the BFD; otherwise it is allocated
124    on OBJFILE's obstack.  Note that it is not safe to call this
125    multiple times for a given OBJFILE -- it can only be called when
126    allocating or re-initializing OBJFILE.  */
127
128 static struct objfile_per_bfd_storage *
129 get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
130 {
131   struct objfile_per_bfd_storage *storage = NULL;
132
133   if (abfd != NULL)
134     storage = ((struct objfile_per_bfd_storage *)
135                bfd_data (abfd, objfiles_bfd_data));
136
137   if (storage == NULL)
138     {
139       /* If the object requires gdb to do relocations, we simply fall
140          back to not sharing data across users.  These cases are rare
141          enough that this seems reasonable.  */
142       if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
143         {
144           storage
145             = ((struct objfile_per_bfd_storage *)
146                bfd_alloc (abfd, sizeof (struct objfile_per_bfd_storage)));
147           /* objfile_per_bfd_storage is not trivially constructible, must
148              call the ctor manually.  */
149           storage = new (storage) objfile_per_bfd_storage ();
150           set_bfd_data (abfd, objfiles_bfd_data, storage);
151         }
152       else
153         storage
154           = obstack_new<objfile_per_bfd_storage> (&objfile->objfile_obstack);
155
156       /* Look up the gdbarch associated with the BFD.  */
157       if (abfd != NULL)
158         storage->gdbarch = gdbarch_from_bfd (abfd);
159
160       storage->filename_cache = bcache_xmalloc (NULL, NULL);
161       storage->macro_cache = bcache_xmalloc (NULL, NULL);
162       storage->language_of_main = language_unknown;
163     }
164
165   return storage;
166 }
167
168 /* Free STORAGE.  */
169
170 static void
171 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage *storage)
172 {
173   bcache_xfree (storage->filename_cache);
174   bcache_xfree (storage->macro_cache);
175   if (storage->demangled_names_hash)
176     htab_delete (storage->demangled_names_hash);
177   storage->~objfile_per_bfd_storage ();
178 }
179
180 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
181    cleanup function to the BFD registry.  */
182
183 static void
184 objfile_bfd_data_free (struct bfd *unused, void *d)
185 {
186   free_objfile_per_bfd_storage ((struct objfile_per_bfd_storage *) d);
187 }
188
189 /* See objfiles.h.  */
190
191 void
192 set_objfile_per_bfd (struct objfile *objfile)
193 {
194   objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd);
195 }
196
197 /* Set the objfile's per-BFD notion of the "main" name and
198    language.  */
199
200 void
201 set_objfile_main_name (struct objfile *objfile,
202                        const char *name, enum language lang)
203 {
204   if (objfile->per_bfd->name_of_main == NULL
205       || strcmp (objfile->per_bfd->name_of_main, name) != 0)
206     objfile->per_bfd->name_of_main
207       = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack, name,
208                                       strlen (name));
209   objfile->per_bfd->language_of_main = lang;
210 }
211
212 /* Helper structure to map blocks to static link properties in hash tables.  */
213
214 struct static_link_htab_entry
215 {
216   const struct block *block;
217   const struct dynamic_prop *static_link;
218 };
219
220 /* Return a hash code for struct static_link_htab_entry *P.  */
221
222 static hashval_t
223 static_link_htab_entry_hash (const void *p)
224 {
225   const struct static_link_htab_entry *e
226     = (const struct static_link_htab_entry *) p;
227
228   return htab_hash_pointer (e->block);
229 }
230
231 /* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
232    mappings for the same block.  */
233
234 static int
235 static_link_htab_entry_eq (const void *p1, const void *p2)
236 {
237   const struct static_link_htab_entry *e1
238     = (const struct static_link_htab_entry *) p1;
239   const struct static_link_htab_entry *e2
240     = (const struct static_link_htab_entry *) p2;
241
242   return e1->block == e2->block;
243 }
244
245 /* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
246    Must not be called more than once for each BLOCK.  */
247
248 void
249 objfile_register_static_link (struct objfile *objfile,
250                               const struct block *block,
251                               const struct dynamic_prop *static_link)
252 {
253   void **slot;
254   struct static_link_htab_entry lookup_entry;
255   struct static_link_htab_entry *entry;
256
257   if (objfile->static_links == NULL)
258     objfile->static_links = htab_create_alloc
259       (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL,
260        xcalloc, xfree);
261
262   /* Create a slot for the mapping, make sure it's the first mapping for this
263      block and then create the mapping itself.  */
264   lookup_entry.block = block;
265   slot = htab_find_slot (objfile->static_links, &lookup_entry, INSERT);
266   gdb_assert (*slot == NULL);
267
268   entry = XOBNEW (&objfile->objfile_obstack, static_link_htab_entry);
269   entry->block = block;
270   entry->static_link = static_link;
271   *slot = (void *) entry;
272 }
273
274 /* Look for a static link for BLOCK, which is part of OBJFILE.  Return NULL if
275    none was found.  */
276
277 const struct dynamic_prop *
278 objfile_lookup_static_link (struct objfile *objfile,
279                             const struct block *block)
280 {
281   struct static_link_htab_entry *entry;
282   struct static_link_htab_entry lookup_entry;
283
284   if (objfile->static_links == NULL)
285     return NULL;
286   lookup_entry.block = block;
287   entry
288     = (struct static_link_htab_entry *) htab_find (objfile->static_links,
289                                                    &lookup_entry);
290   if (entry == NULL)
291     return NULL;
292
293   gdb_assert (entry->block == block);
294   return entry->static_link;
295 }
296
297 \f
298
299 /* Called via bfd_map_over_sections to build up the section table that
300    the objfile references.  The objfile contains pointers to the start
301    of the table (objfile->sections) and to the first location after
302    the end of the table (objfile->sections_end).  */
303
304 static void
305 add_to_objfile_sections_full (struct bfd *abfd, struct bfd_section *asect,
306                               struct objfile *objfile, int force)
307 {
308   struct obj_section *section;
309
310   if (!force)
311     {
312       flagword aflag;
313
314       aflag = bfd_get_section_flags (abfd, asect);
315       if (!(aflag & SEC_ALLOC))
316         return;
317     }
318
319   section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
320   section->objfile = objfile;
321   section->the_bfd_section = asect;
322   section->ovly_mapped = 0;
323 }
324
325 static void
326 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
327                          void *objfilep)
328 {
329   add_to_objfile_sections_full (abfd, asect, (struct objfile *) objfilep, 0);
330 }
331
332 /* Builds a section table for OBJFILE.
333
334    Note that the OFFSET and OVLY_MAPPED in each table entry are
335    initialized to zero.  */
336
337 void
338 build_objfile_section_table (struct objfile *objfile)
339 {
340   int count = gdb_bfd_count_sections (objfile->obfd);
341
342   objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
343                                       count,
344                                       struct obj_section);
345   objfile->sections_end = (objfile->sections + count);
346   bfd_map_over_sections (objfile->obfd,
347                          add_to_objfile_sections, (void *) objfile);
348
349   /* See gdb_bfd_section_index.  */
350   add_to_objfile_sections_full (objfile->obfd, bfd_com_section_ptr, objfile, 1);
351   add_to_objfile_sections_full (objfile->obfd, bfd_und_section_ptr, objfile, 1);
352   add_to_objfile_sections_full (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
353   add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
354 }
355
356 /* Given a pointer to an initialized bfd (ABFD) and some flag bits,
357    initialize the new objfile as best we can and link it into the list
358    of all known objfiles.
359
360    NAME should contain original non-canonicalized filename or other
361    identifier as entered by user.  If there is no better source use
362    bfd_get_filename (ABFD).  NAME may be NULL only if ABFD is NULL.
363    NAME content is copied into returned objfile.
364
365    The FLAGS word contains various bits (OBJF_*) that can be taken as
366    requests for specific operations.  Other bits like OBJF_SHARED are
367    simply copied through to the new objfile flags member.  */
368
369 objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
370   : flags (flags_),
371     pspace (current_program_space),
372     partial_symtabs (new psymtab_storage ()),
373     obfd (abfd)
374 {
375   const char *expanded_name;
376
377   /* We could use obstack_specify_allocation here instead, but
378      gdb_obstack.h specifies the alloc/dealloc functions.  */
379   obstack_init (&objfile_obstack);
380
381   objfile_alloc_data (this);
382
383   gdb::unique_xmalloc_ptr<char> name_holder;
384   if (name == NULL)
385     {
386       gdb_assert (abfd == NULL);
387       gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
388       expanded_name = "<<anonymous objfile>>";
389     }
390   else if ((flags & OBJF_NOT_FILENAME) != 0
391            || is_target_filename (name))
392     expanded_name = name;
393   else
394     {
395       name_holder = gdb_abspath (name);
396       expanded_name = name_holder.get ();
397     }
398   original_name
399     = (char *) obstack_copy0 (&objfile_obstack,
400                               expanded_name,
401                               strlen (expanded_name));
402
403   /* Update the per-objfile information that comes from the bfd, ensuring
404      that any data that is reference is saved in the per-objfile data
405      region.  */
406
407   gdb_bfd_ref (abfd);
408   if (abfd != NULL)
409     {
410       mtime = bfd_get_mtime (abfd);
411
412       /* Build section table.  */
413       build_objfile_section_table (this);
414     }
415
416   per_bfd = get_objfile_bfd_data (this, abfd);
417
418   terminate_minimal_symbol_table (this);
419
420   /* Add this file onto the tail of the linked list of other such files.  */
421
422   if (object_files == NULL)
423     object_files = this;
424   else
425     {
426       struct objfile *last_one;
427
428       for (last_one = object_files;
429            last_one->next;
430            last_one = last_one->next);
431       last_one->next = this;
432     }
433
434   /* Rebuild section map next time we need it.  */
435   get_objfile_pspace_data (pspace)->new_objfiles_available = 1;
436 }
437
438 /* Retrieve the gdbarch associated with OBJFILE.  */
439
440 struct gdbarch *
441 get_objfile_arch (const struct objfile *objfile)
442 {
443   return objfile->per_bfd->gdbarch;
444 }
445
446 /* If there is a valid and known entry point, function fills *ENTRY_P with it
447    and returns non-zero; otherwise it returns zero.  */
448
449 int
450 entry_point_address_query (CORE_ADDR *entry_p)
451 {
452   if (symfile_objfile == NULL || !symfile_objfile->per_bfd->ei.entry_point_p)
453     return 0;
454
455   *entry_p = (symfile_objfile->per_bfd->ei.entry_point
456               + ANOFFSET (symfile_objfile->section_offsets,
457                           symfile_objfile->per_bfd->ei.the_bfd_section_index));
458
459   return 1;
460 }
461
462 /* Get current entry point address.  Call error if it is not known.  */
463
464 CORE_ADDR
465 entry_point_address (void)
466 {
467   CORE_ADDR retval;
468
469   if (!entry_point_address_query (&retval))
470     error (_("Entry point address is not known."));
471
472   return retval;
473 }
474
475 /* Iterator on PARENT and every separate debug objfile of PARENT.
476    The usage pattern is:
477      for (objfile = parent;
478           objfile;
479           objfile = objfile_separate_debug_iterate (parent, objfile))
480        ...
481 */
482
483 struct objfile *
484 objfile_separate_debug_iterate (const struct objfile *parent,
485                                 const struct objfile *objfile)
486 {
487   struct objfile *res;
488
489   /* If any, return the first child.  */
490   res = objfile->separate_debug_objfile;
491   if (res)
492     return res;
493
494   /* Common case where there is no separate debug objfile.  */
495   if (objfile == parent)
496     return NULL;
497
498   /* Return the brother if any.  Note that we don't iterate on brothers of
499      the parents.  */
500   res = objfile->separate_debug_objfile_link;
501   if (res)
502     return res;
503
504   for (res = objfile->separate_debug_objfile_backlink;
505        res != parent;
506        res = res->separate_debug_objfile_backlink)
507     {
508       gdb_assert (res != NULL);
509       if (res->separate_debug_objfile_link)
510         return res->separate_debug_objfile_link;
511     }
512   return NULL;
513 }
514
515 /* Put one object file before a specified on in the global list.
516    This can be used to make sure an object file is destroyed before
517    another when using objfiles_safe to free all objfiles.  */
518 void
519 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
520 {
521   struct objfile **objp;
522
523   unlink_objfile (objfile);
524   
525   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
526     {
527       if (*objp == before_this)
528         {
529           objfile->next = *objp;
530           *objp = objfile;
531           return;
532         }
533     }
534   
535   internal_error (__FILE__, __LINE__,
536                   _("put_objfile_before: before objfile not in list"));
537 }
538
539 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
540    list.
541
542    It is not a bug, or error, to call this function if OBJFILE is not known
543    to be in the current list.  This is done in the case of mapped objfiles,
544    for example, just to ensure that the mapped objfile doesn't appear twice
545    in the list.  Since the list is threaded, linking in a mapped objfile
546    twice would create a circular list.
547
548    If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
549    unlinking it, just to ensure that we have completely severed any linkages
550    between the OBJFILE and the list.  */
551
552 void
553 unlink_objfile (struct objfile *objfile)
554 {
555   struct objfile **objpp;
556
557   for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
558     {
559       if (*objpp == objfile)
560         {
561           *objpp = (*objpp)->next;
562           objfile->next = NULL;
563           return;
564         }
565     }
566
567   internal_error (__FILE__, __LINE__,
568                   _("unlink_objfile: objfile already unlinked"));
569 }
570
571 /* Add OBJFILE as a separate debug objfile of PARENT.  */
572
573 void
574 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
575 {
576   gdb_assert (objfile && parent);
577
578   /* Must not be already in a list.  */
579   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
580   gdb_assert (objfile->separate_debug_objfile_link == NULL);
581   gdb_assert (objfile->separate_debug_objfile == NULL);
582   gdb_assert (parent->separate_debug_objfile_backlink == NULL);
583   gdb_assert (parent->separate_debug_objfile_link == NULL);
584
585   objfile->separate_debug_objfile_backlink = parent;
586   objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
587   parent->separate_debug_objfile = objfile;
588
589   /* Put the separate debug object before the normal one, this is so that
590      usage of objfiles_safe will stay safe.  */
591   put_objfile_before (objfile, parent);
592 }
593
594 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
595    itself.  */
596
597 void
598 free_objfile_separate_debug (struct objfile *objfile)
599 {
600   struct objfile *child;
601
602   for (child = objfile->separate_debug_objfile; child;)
603     {
604       struct objfile *next_child = child->separate_debug_objfile_link;
605       delete child;
606       child = next_child;
607     }
608 }
609
610 /* Destroy an objfile and all the symtabs and psymtabs under it.  */
611
612 objfile::~objfile ()
613 {
614   /* First notify observers that this objfile is about to be freed.  */
615   gdb::observers::free_objfile.notify (this);
616
617   /* Free all separate debug objfiles.  */
618   free_objfile_separate_debug (this);
619
620   if (separate_debug_objfile_backlink)
621     {
622       /* We freed the separate debug file, make sure the base objfile
623          doesn't reference it.  */
624       struct objfile *child;
625
626       child = separate_debug_objfile_backlink->separate_debug_objfile;
627
628       if (child == this)
629         {
630           /* THIS is the first child.  */
631           separate_debug_objfile_backlink->separate_debug_objfile =
632             separate_debug_objfile_link;
633         }
634       else
635         {
636           /* Find THIS in the list.  */
637           while (1)
638             {
639               if (child->separate_debug_objfile_link == this)
640                 {
641                   child->separate_debug_objfile_link =
642                     separate_debug_objfile_link;
643                   break;
644                 }
645               child = child->separate_debug_objfile_link;
646               gdb_assert (child);
647             }
648         }
649     }
650
651   /* Remove any references to this objfile in the global value
652      lists.  */
653   preserve_values (this);
654
655   /* It still may reference data modules have associated with the objfile and
656      the symbol file data.  */
657   forget_cached_source_info_for_objfile (this);
658
659   breakpoint_free_objfile (this);
660   btrace_free_objfile (this);
661
662   /* First do any symbol file specific actions required when we are
663      finished with a particular symbol file.  Note that if the objfile
664      is using reusable symbol information (via mmalloc) then each of
665      these routines is responsible for doing the correct thing, either
666      freeing things which are valid only during this particular gdb
667      execution, or leaving them to be reused during the next one.  */
668
669   if (sf != NULL)
670     (*sf->sym_finish) (this);
671
672   /* Discard any data modules have associated with the objfile.  The function
673      still may reference obfd.  */
674   objfile_free_data (this);
675
676   if (obfd)
677     gdb_bfd_unref (obfd);
678   else
679     free_objfile_per_bfd_storage (per_bfd);
680
681   /* Remove it from the chain of all objfiles.  */
682
683   unlink_objfile (this);
684
685   if (this == symfile_objfile)
686     symfile_objfile = NULL;
687
688   /* Before the symbol table code was redone to make it easier to
689      selectively load and remove information particular to a specific
690      linkage unit, gdb used to do these things whenever the monolithic
691      symbol table was blown away.  How much still needs to be done
692      is unknown, but we play it safe for now and keep each action until
693      it is shown to be no longer needed.  */
694
695   /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
696      for example), so we need to call this here.  */
697   clear_pc_function_cache ();
698
699   /* Clear globals which might have pointed into a removed objfile.
700      FIXME: It's not clear which of these are supposed to persist
701      between expressions and which ought to be reset each time.  */
702   expression_context_block = NULL;
703   innermost_block.reset ();
704
705   /* Check to see if the current_source_symtab belongs to this objfile,
706      and if so, call clear_current_source_symtab_and_line.  */
707
708   {
709     struct symtab_and_line cursal = get_current_source_symtab_and_line ();
710
711     if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == this)
712       clear_current_source_symtab_and_line ();
713   }
714
715   /* Free the obstacks for non-reusable objfiles.  */
716   obstack_free (&objfile_obstack, 0);
717
718   /* Rebuild section map next time we need it.  */
719   get_objfile_pspace_data (pspace)->section_map_dirty = 1;
720
721   /* Free the map for static links.  There's no need to free static link
722      themselves since they were allocated on the objstack.  */
723   if (static_links != NULL)
724     htab_delete (static_links);
725 }
726
727 /* Free all the object files at once and clean up their users.  */
728
729 void
730 free_all_objfiles (void)
731 {
732   struct so_list *so;
733
734   /* Any objfile referencewould become stale.  */
735   for (so = master_so_list (); so; so = so->next)
736     gdb_assert (so->objfile == NULL);
737
738   for (objfile *objfile : current_program_space->objfiles_safe ())
739     delete objfile;
740   clear_symtab_users (0);
741 }
742 \f
743 /* A helper function for objfile_relocate1 that relocates a single
744    symbol.  */
745
746 static void
747 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
748                      struct section_offsets *delta)
749 {
750   fixup_symbol_section (sym, objfile);
751
752   /* The RS6000 code from which this was taken skipped
753      any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
754      But I'm leaving out that test, on the theory that
755      they can't possibly pass the tests below.  */
756   if ((SYMBOL_CLASS (sym) == LOC_LABEL
757        || SYMBOL_CLASS (sym) == LOC_STATIC)
758       && SYMBOL_SECTION (sym) >= 0)
759     {
760       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
761     }
762 }
763
764 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
765    entries in new_offsets.  SEPARATE_DEBUG_OBJFILE is not touched here.
766    Return non-zero iff any change happened.  */
767
768 static int
769 objfile_relocate1 (struct objfile *objfile, 
770                    const struct section_offsets *new_offsets)
771 {
772   struct section_offsets *delta =
773     ((struct section_offsets *) 
774      alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
775
776   int something_changed = 0;
777
778   for (int i = 0; i < objfile->num_sections; ++i)
779     {
780       delta->offsets[i] =
781         ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
782       if (ANOFFSET (delta, i) != 0)
783         something_changed = 1;
784     }
785   if (!something_changed)
786     return 0;
787
788   /* OK, get all the symtabs.  */
789   {
790     for (compunit_symtab *cust : objfile->compunits ())
791       {
792         for (symtab *s : compunit_filetabs (cust))
793           {
794             struct linetable *l;
795
796             /* First the line table.  */
797             l = SYMTAB_LINETABLE (s);
798             if (l)
799               {
800                 for (int i = 0; i < l->nitems; ++i)
801                   l->item[i].pc += ANOFFSET (delta,
802                                              COMPUNIT_BLOCK_LINE_SECTION
803                                              (cust));
804               }
805           }
806       }
807
808     for (compunit_symtab *cust : objfile->compunits ())
809       {
810         const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
811         int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust);
812
813         if (BLOCKVECTOR_MAP (bv))
814           addrmap_relocate (BLOCKVECTOR_MAP (bv),
815                             ANOFFSET (delta, block_line_section));
816
817         for (int i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
818           {
819             struct block *b;
820             struct symbol *sym;
821             struct mdict_iterator miter;
822
823             b = BLOCKVECTOR_BLOCK (bv, i);
824             BLOCK_START (b) += ANOFFSET (delta, block_line_section);
825             BLOCK_END (b) += ANOFFSET (delta, block_line_section);
826
827             if (BLOCK_RANGES (b) != nullptr)
828               for (int j = 0; j < BLOCK_NRANGES (b); j++)
829                 {
830                   BLOCK_RANGE_START (b, j)
831                     += ANOFFSET (delta, block_line_section);
832                   BLOCK_RANGE_END (b, j) += ANOFFSET (delta,
833                                                       block_line_section);
834                 }
835
836             /* We only want to iterate over the local symbols, not any
837                symbols in included symtabs.  */
838             ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
839               {
840                 relocate_one_symbol (sym, objfile, delta);
841               }
842           }
843       }
844   }
845
846   /* This stores relocated addresses and so must be cleared.  This
847      will cause it to be recreated on demand.  */
848   objfile->psymbol_map.clear ();
849
850   /* Relocate isolated symbols.  */
851   {
852     struct symbol *iter;
853
854     for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
855       relocate_one_symbol (iter, objfile, delta);
856   }
857
858   {
859     int i;
860
861     for (i = 0; i < objfile->num_sections; ++i)
862       (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
863   }
864
865   /* Rebuild section map next time we need it.  */
866   get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
867
868   /* Update the table in exec_ops, used to read memory.  */
869   struct obj_section *s;
870   ALL_OBJFILE_OSECTIONS (objfile, s)
871     {
872       int idx = s - objfile->sections;
873
874       exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
875                                 obj_section_addr (s));
876     }
877
878   /* Data changed.  */
879   return 1;
880 }
881
882 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
883    entries in new_offsets.  Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
884
885    The number and ordering of sections does differ between the two objfiles.
886    Only their names match.  Also the file offsets will differ (objfile being
887    possibly prelinked but separate_debug_objfile is probably not prelinked) but
888    the in-memory absolute address as specified by NEW_OFFSETS must match both
889    files.  */
890
891 void
892 objfile_relocate (struct objfile *objfile,
893                   const struct section_offsets *new_offsets)
894 {
895   struct objfile *debug_objfile;
896   int changed = 0;
897
898   changed |= objfile_relocate1 (objfile, new_offsets);
899
900   for (debug_objfile = objfile->separate_debug_objfile;
901        debug_objfile;
902        debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
903     {
904       section_addr_info objfile_addrs
905         = build_section_addr_info_from_objfile (objfile);
906
907       /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
908          relative ones must be already created according to debug_objfile.  */
909
910       addr_info_make_relative (&objfile_addrs, debug_objfile->obfd);
911
912       gdb_assert (debug_objfile->num_sections
913                   == gdb_bfd_count_sections (debug_objfile->obfd));
914       std::vector<struct section_offsets>
915         new_debug_offsets (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
916       relative_addr_info_to_section_offsets (new_debug_offsets.data (),
917                                              debug_objfile->num_sections,
918                                              objfile_addrs);
919
920       changed |= objfile_relocate1 (debug_objfile, new_debug_offsets.data ());
921     }
922
923   /* Relocate breakpoints as necessary, after things are relocated.  */
924   if (changed)
925     breakpoint_re_set ();
926 }
927
928 /* Rebase (add to the offsets) OBJFILE by SLIDE.  SEPARATE_DEBUG_OBJFILE is
929    not touched here.
930    Return non-zero iff any change happened.  */
931
932 static int
933 objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
934 {
935   struct section_offsets *new_offsets =
936     ((struct section_offsets *)
937      alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
938   int i;
939
940   for (i = 0; i < objfile->num_sections; ++i)
941     new_offsets->offsets[i] = slide;
942
943   return objfile_relocate1 (objfile, new_offsets);
944 }
945
946 /* Rebase (add to the offsets) OBJFILE by SLIDE.  Process also OBJFILE's
947    SEPARATE_DEBUG_OBJFILEs.  */
948
949 void
950 objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
951 {
952   struct objfile *debug_objfile;
953   int changed = 0;
954
955   changed |= objfile_rebase1 (objfile, slide);
956
957   for (debug_objfile = objfile->separate_debug_objfile;
958        debug_objfile;
959        debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
960     changed |= objfile_rebase1 (debug_objfile, slide);
961
962   /* Relocate breakpoints as necessary, after things are relocated.  */
963   if (changed)
964     breakpoint_re_set ();
965 }
966 \f
967 /* Return non-zero if OBJFILE has partial symbols.  */
968
969 int
970 objfile_has_partial_symbols (struct objfile *objfile)
971 {
972   if (!objfile->sf)
973     return 0;
974
975   /* If we have not read psymbols, but we have a function capable of reading
976      them, then that is an indication that they are in fact available.  Without
977      this function the symbols may have been already read in but they also may
978      not be present in this objfile.  */
979   if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
980       && objfile->sf->sym_read_psymbols != NULL)
981     return 1;
982
983   return objfile->sf->qf->has_symbols (objfile);
984 }
985
986 /* Return non-zero if OBJFILE has full symbols.  */
987
988 int
989 objfile_has_full_symbols (struct objfile *objfile)
990 {
991   return objfile->compunit_symtabs != NULL;
992 }
993
994 /* Return non-zero if OBJFILE has full or partial symbols, either directly
995    or through a separate debug file.  */
996
997 int
998 objfile_has_symbols (struct objfile *objfile)
999 {
1000   struct objfile *o;
1001
1002   for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
1003     if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
1004       return 1;
1005   return 0;
1006 }
1007
1008
1009 /* Many places in gdb want to test just to see if we have any partial
1010    symbols available.  This function returns zero if none are currently
1011    available, nonzero otherwise.  */
1012
1013 int
1014 have_partial_symbols (void)
1015 {
1016   for (objfile *ofp : current_program_space->objfiles ())
1017     {
1018       if (objfile_has_partial_symbols (ofp))
1019         return 1;
1020     }
1021   return 0;
1022 }
1023
1024 /* Many places in gdb want to test just to see if we have any full
1025    symbols available.  This function returns zero if none are currently
1026    available, nonzero otherwise.  */
1027
1028 int
1029 have_full_symbols (void)
1030 {
1031   for (objfile *ofp : current_program_space->objfiles ())
1032     {
1033       if (objfile_has_full_symbols (ofp))
1034         return 1;
1035     }
1036   return 0;
1037 }
1038
1039
1040 /* This operations deletes all objfile entries that represent solibs that
1041    weren't explicitly loaded by the user, via e.g., the add-symbol-file
1042    command.  */
1043
1044 void
1045 objfile_purge_solibs (void)
1046 {
1047   for (objfile *objf : current_program_space->objfiles_safe ())
1048     {
1049       /* We assume that the solib package has been purged already, or will
1050          be soon.  */
1051
1052       if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
1053         delete objf;
1054     }
1055 }
1056
1057
1058 /* Many places in gdb want to test just to see if we have any minimal
1059    symbols available.  This function returns zero if none are currently
1060    available, nonzero otherwise.  */
1061
1062 int
1063 have_minimal_symbols (void)
1064 {
1065   for (objfile *ofp : current_program_space->objfiles ())
1066     {
1067       if (ofp->per_bfd->minimal_symbol_count > 0)
1068         {
1069           return 1;
1070         }
1071     }
1072   return 0;
1073 }
1074
1075 /* Qsort comparison function.  */
1076
1077 static int
1078 qsort_cmp (const void *a, const void *b)
1079 {
1080   const struct obj_section *sect1 = *(const struct obj_section **) a;
1081   const struct obj_section *sect2 = *(const struct obj_section **) b;
1082   const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1083   const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1084
1085   if (sect1_addr < sect2_addr)
1086     return -1;
1087   else if (sect1_addr > sect2_addr)
1088     return 1;
1089   else
1090     {
1091       /* Sections are at the same address.  This could happen if
1092          A) we have an objfile and a separate debuginfo.
1093          B) we are confused, and have added sections without proper relocation,
1094          or something like that.  */
1095
1096       const struct objfile *const objfile1 = sect1->objfile;
1097       const struct objfile *const objfile2 = sect2->objfile;
1098
1099       if (objfile1->separate_debug_objfile == objfile2
1100           || objfile2->separate_debug_objfile == objfile1)
1101         {
1102           /* Case A.  The ordering doesn't matter: separate debuginfo files
1103              will be filtered out later.  */
1104
1105           return 0;
1106         }
1107
1108       /* Case B.  Maintain stable sort order, so bugs in GDB are easier to
1109          triage.  This section could be slow (since we iterate over all
1110          objfiles in each call to qsort_cmp), but this shouldn't happen
1111          very often (GDB is already in a confused state; one hopes this
1112          doesn't happen at all).  If you discover that significant time is
1113          spent in the loops below, do 'set complaints 100' and examine the
1114          resulting complaints.  */
1115
1116       if (objfile1 == objfile2)
1117         {
1118           /* Both sections came from the same objfile.  We are really confused.
1119              Sort on sequence order of sections within the objfile.  */
1120
1121           const struct obj_section *osect;
1122
1123           ALL_OBJFILE_OSECTIONS (objfile1, osect)
1124             if (osect == sect1)
1125               return -1;
1126             else if (osect == sect2)
1127               return 1;
1128
1129           /* We should have found one of the sections before getting here.  */
1130           gdb_assert_not_reached ("section not found");
1131         }
1132       else
1133         {
1134           /* Sort on sequence number of the objfile in the chain.  */
1135
1136           for (objfile *objfile : current_program_space->objfiles ())
1137             if (objfile == objfile1)
1138               return -1;
1139             else if (objfile == objfile2)
1140               return 1;
1141
1142           /* We should have found one of the objfiles before getting here.  */
1143           gdb_assert_not_reached ("objfile not found");
1144         }
1145     }
1146
1147   /* Unreachable.  */
1148   gdb_assert_not_reached ("unexpected code path");
1149   return 0;
1150 }
1151
1152 /* Select "better" obj_section to keep.  We prefer the one that came from
1153    the real object, rather than the one from separate debuginfo.
1154    Most of the time the two sections are exactly identical, but with
1155    prelinking the .rel.dyn section in the real object may have different
1156    size.  */
1157
1158 static struct obj_section *
1159 preferred_obj_section (struct obj_section *a, struct obj_section *b)
1160 {
1161   gdb_assert (obj_section_addr (a) == obj_section_addr (b));
1162   gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
1163               || (b->objfile->separate_debug_objfile == a->objfile));
1164   gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
1165               || (b->objfile->separate_debug_objfile_backlink == a->objfile));
1166
1167   if (a->objfile->separate_debug_objfile != NULL)
1168     return a;
1169   return b;
1170 }
1171
1172 /* Return 1 if SECTION should be inserted into the section map.
1173    We want to insert only non-overlay and non-TLS section.  */
1174
1175 static int
1176 insert_section_p (const struct bfd *abfd,
1177                   const struct bfd_section *section)
1178 {
1179   const bfd_vma lma = bfd_section_lma (abfd, section);
1180
1181   if (overlay_debugging && lma != 0 && lma != bfd_section_vma (abfd, section)
1182       && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1183     /* This is an overlay section.  IN_MEMORY check is needed to avoid
1184        discarding sections from the "system supplied DSO" (aka vdso)
1185        on some Linux systems (e.g. Fedora 11).  */
1186     return 0;
1187   if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1188     /* This is a TLS section.  */
1189     return 0;
1190
1191   return 1;
1192 }
1193
1194 /* Filter out overlapping sections where one section came from the real
1195    objfile, and the other from a separate debuginfo file.
1196    Return the size of table after redundant sections have been eliminated.  */
1197
1198 static int
1199 filter_debuginfo_sections (struct obj_section **map, int map_size)
1200 {
1201   int i, j;
1202
1203   for (i = 0, j = 0; i < map_size - 1; i++)
1204     {
1205       struct obj_section *const sect1 = map[i];
1206       struct obj_section *const sect2 = map[i + 1];
1207       const struct objfile *const objfile1 = sect1->objfile;
1208       const struct objfile *const objfile2 = sect2->objfile;
1209       const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1210       const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1211
1212       if (sect1_addr == sect2_addr
1213           && (objfile1->separate_debug_objfile == objfile2
1214               || objfile2->separate_debug_objfile == objfile1))
1215         {
1216           map[j++] = preferred_obj_section (sect1, sect2);
1217           ++i;
1218         }
1219       else
1220         map[j++] = sect1;
1221     }
1222
1223   if (i < map_size)
1224     {
1225       gdb_assert (i == map_size - 1);
1226       map[j++] = map[i];
1227     }
1228
1229   /* The map should not have shrunk to less than half the original size.  */
1230   gdb_assert (map_size / 2 <= j);
1231
1232   return j;
1233 }
1234
1235 /* Filter out overlapping sections, issuing a warning if any are found.
1236    Overlapping sections could really be overlay sections which we didn't
1237    classify as such in insert_section_p, or we could be dealing with a
1238    corrupt binary.  */
1239
1240 static int
1241 filter_overlapping_sections (struct obj_section **map, int map_size)
1242 {
1243   int i, j;
1244
1245   for (i = 0, j = 0; i < map_size - 1; )
1246     {
1247       int k;
1248
1249       map[j++] = map[i];
1250       for (k = i + 1; k < map_size; k++)
1251         {
1252           struct obj_section *const sect1 = map[i];
1253           struct obj_section *const sect2 = map[k];
1254           const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1255           const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1256           const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1257
1258           gdb_assert (sect1_addr <= sect2_addr);
1259
1260           if (sect1_endaddr <= sect2_addr)
1261             break;
1262           else
1263             {
1264               /* We have an overlap.  Report it.  */
1265
1266               struct objfile *const objf1 = sect1->objfile;
1267               struct objfile *const objf2 = sect2->objfile;
1268
1269               const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1270               const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1271
1272               const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1273
1274               struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1275
1276               complaint (_("unexpected overlap between:\n"
1277                            " (A) section `%s' from `%s' [%s, %s)\n"
1278                            " (B) section `%s' from `%s' [%s, %s).\n"
1279                            "Will ignore section B"),
1280                          bfd_section_name (abfd1, bfds1), objfile_name (objf1),
1281                          paddress (gdbarch, sect1_addr),
1282                          paddress (gdbarch, sect1_endaddr),
1283                          bfd_section_name (abfd2, bfds2), objfile_name (objf2),
1284                          paddress (gdbarch, sect2_addr),
1285                          paddress (gdbarch, sect2_endaddr));
1286             }
1287         }
1288       i = k;
1289     }
1290
1291   if (i < map_size)
1292     {
1293       gdb_assert (i == map_size - 1);
1294       map[j++] = map[i];
1295     }
1296
1297   return j;
1298 }
1299
1300
1301 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1302    TLS, overlay and overlapping sections.  */
1303
1304 static void
1305 update_section_map (struct program_space *pspace,
1306                     struct obj_section ***pmap, int *pmap_size)
1307 {
1308   struct objfile_pspace_info *pspace_info;
1309   int alloc_size, map_size, i;
1310   struct obj_section *s, **map;
1311
1312   pspace_info = get_objfile_pspace_data (pspace);
1313   gdb_assert (pspace_info->section_map_dirty != 0
1314               || pspace_info->new_objfiles_available != 0);
1315
1316   map = *pmap;
1317   xfree (map);
1318
1319   alloc_size = 0;
1320   for (objfile *objfile : pspace->objfiles ())
1321     ALL_OBJFILE_OSECTIONS (objfile, s)
1322       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1323         alloc_size += 1;
1324
1325   /* This happens on detach/attach (e.g. in gdb.base/attach.exp).  */
1326   if (alloc_size == 0)
1327     {
1328       *pmap = NULL;
1329       *pmap_size = 0;
1330       return;
1331     }
1332
1333   map = XNEWVEC (struct obj_section *, alloc_size);
1334
1335   i = 0;
1336   for (objfile *objfile : pspace->objfiles ())
1337     ALL_OBJFILE_OSECTIONS (objfile, s)
1338       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1339         map[i++] = s;
1340
1341   qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1342   map_size = filter_debuginfo_sections(map, alloc_size);
1343   map_size = filter_overlapping_sections(map, map_size);
1344
1345   if (map_size < alloc_size)
1346     /* Some sections were eliminated.  Trim excess space.  */
1347     map = XRESIZEVEC (struct obj_section *, map, map_size);
1348   else
1349     gdb_assert (alloc_size == map_size);
1350
1351   *pmap = map;
1352   *pmap_size = map_size;
1353 }
1354
1355 /* Bsearch comparison function.  */
1356
1357 static int
1358 bsearch_cmp (const void *key, const void *elt)
1359 {
1360   const CORE_ADDR pc = *(CORE_ADDR *) key;
1361   const struct obj_section *section = *(const struct obj_section **) elt;
1362
1363   if (pc < obj_section_addr (section))
1364     return -1;
1365   if (pc < obj_section_endaddr (section))
1366     return 0;
1367   return 1;
1368 }
1369
1370 /* Returns a section whose range includes PC or NULL if none found.   */
1371
1372 struct obj_section *
1373 find_pc_section (CORE_ADDR pc)
1374 {
1375   struct objfile_pspace_info *pspace_info;
1376   struct obj_section *s, **sp;
1377
1378   /* Check for mapped overlay section first.  */
1379   s = find_pc_mapped_section (pc);
1380   if (s)
1381     return s;
1382
1383   pspace_info = get_objfile_pspace_data (current_program_space);
1384   if (pspace_info->section_map_dirty
1385       || (pspace_info->new_objfiles_available
1386           && !pspace_info->inhibit_updates))
1387     {
1388       update_section_map (current_program_space,
1389                           &pspace_info->sections,
1390                           &pspace_info->num_sections);
1391
1392       /* Don't need updates to section map until objfiles are added,
1393          removed or relocated.  */
1394       pspace_info->new_objfiles_available = 0;
1395       pspace_info->section_map_dirty = 0;
1396     }
1397
1398   /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1399      bsearch be non-NULL.  */
1400   if (pspace_info->sections == NULL)
1401     {
1402       gdb_assert (pspace_info->num_sections == 0);
1403       return NULL;
1404     }
1405
1406   sp = (struct obj_section **) bsearch (&pc,
1407                                         pspace_info->sections,
1408                                         pspace_info->num_sections,
1409                                         sizeof (*pspace_info->sections),
1410                                         bsearch_cmp);
1411   if (sp != NULL)
1412     return *sp;
1413   return NULL;
1414 }
1415
1416
1417 /* Return non-zero if PC is in a section called NAME.  */
1418
1419 int
1420 pc_in_section (CORE_ADDR pc, const char *name)
1421 {
1422   struct obj_section *s;
1423   int retval = 0;
1424
1425   s = find_pc_section (pc);
1426
1427   retval = (s != NULL
1428             && s->the_bfd_section->name != NULL
1429             && strcmp (s->the_bfd_section->name, name) == 0);
1430   return (retval);
1431 }
1432 \f
1433
1434 /* Set section_map_dirty so section map will be rebuilt next time it
1435    is used.  Called by reread_symbols.  */
1436
1437 void
1438 objfiles_changed (void)
1439 {
1440   /* Rebuild section map next time we need it.  */
1441   get_objfile_pspace_data (current_program_space)->section_map_dirty = 1;
1442 }
1443
1444 /* See comments in objfiles.h.  */
1445
1446 scoped_restore_tmpl<int>
1447 inhibit_section_map_updates (struct program_space *pspace)
1448 {
1449   return scoped_restore_tmpl<int>
1450     (&get_objfile_pspace_data (pspace)->inhibit_updates, 1);
1451 }
1452
1453 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1454    otherwise.  */
1455
1456 int
1457 is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile)
1458 {
1459   struct obj_section *osect;
1460
1461   if (objfile == NULL)
1462     return 0;
1463
1464   ALL_OBJFILE_OSECTIONS (objfile, osect)
1465     {
1466       if (section_is_overlay (osect) && !section_is_mapped (osect))
1467         continue;
1468
1469       if (obj_section_addr (osect) <= addr
1470           && addr < obj_section_endaddr (osect))
1471         return 1;
1472     }
1473   return 0;
1474 }
1475
1476 int
1477 shared_objfile_contains_address_p (struct program_space *pspace,
1478                                    CORE_ADDR address)
1479 {
1480   for (objfile *objfile : pspace->objfiles ())
1481     {
1482       if ((objfile->flags & OBJF_SHARED) != 0
1483           && is_addr_in_objfile (address, objfile))
1484         return 1;
1485     }
1486
1487   return 0;
1488 }
1489
1490 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1491    gdbarch method.  It is equivalent to use the objfiles iterable,
1492    searching the objfiles in the order they are stored internally,
1493    ignoring CURRENT_OBJFILE.
1494
1495    On most platorms, it should be close enough to doing the best
1496    we can without some knowledge specific to the architecture.  */
1497
1498 void
1499 default_iterate_over_objfiles_in_search_order
1500   (struct gdbarch *gdbarch,
1501    iterate_over_objfiles_in_search_order_cb_ftype *cb,
1502    void *cb_data, struct objfile *current_objfile)
1503 {
1504   int stop = 0;
1505
1506   for (objfile *objfile : current_program_space->objfiles ())
1507     {
1508        stop = cb (objfile, cb_data);
1509        if (stop)
1510          return;
1511     }
1512 }
1513
1514 /* See objfiles.h.  */
1515
1516 const char *
1517 objfile_name (const struct objfile *objfile)
1518 {
1519   if (objfile->obfd != NULL)
1520     return bfd_get_filename (objfile->obfd);
1521
1522   return objfile->original_name;
1523 }
1524
1525 /* See objfiles.h.  */
1526
1527 const char *
1528 objfile_filename (const struct objfile *objfile)
1529 {
1530   if (objfile->obfd != NULL)
1531     return bfd_get_filename (objfile->obfd);
1532
1533   return NULL;
1534 }
1535
1536 /* See objfiles.h.  */
1537
1538 const char *
1539 objfile_debug_name (const struct objfile *objfile)
1540 {
1541   return lbasename (objfile->original_name);
1542 }
1543
1544 /* See objfiles.h.  */
1545
1546 const char *
1547 objfile_flavour_name (struct objfile *objfile)
1548 {
1549   if (objfile->obfd != NULL)
1550     return bfd_flavour_name (bfd_get_flavour (objfile->obfd));
1551   return NULL;
1552 }
1553
1554 void
1555 _initialize_objfiles (void)
1556 {
1557   objfiles_pspace_data
1558     = register_program_space_data_with_cleanup (NULL,
1559                                                 objfiles_pspace_data_cleanup);
1560
1561   objfiles_bfd_data = register_bfd_data_with_cleanup (NULL,
1562                                                       objfile_bfd_data_free);
1563 }