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