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