relocate the entry point address when used
[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               + ANOFFSET (symfile_objfile->section_offsets,
372                           symfile_objfile->ei.the_bfd_section_index));
373
374   return 1;
375 }
376
377 /* Get current entry point address.  Call error if it is not known.  */
378
379 CORE_ADDR
380 entry_point_address (void)
381 {
382   CORE_ADDR retval;
383
384   if (!entry_point_address_query (&retval))
385     error (_("Entry point address is not known."));
386
387   return retval;
388 }
389
390 /* Iterator on PARENT and every separate debug objfile of PARENT.
391    The usage pattern is:
392      for (objfile = parent;
393           objfile;
394           objfile = objfile_separate_debug_iterate (parent, objfile))
395        ...
396 */
397
398 struct objfile *
399 objfile_separate_debug_iterate (const struct objfile *parent,
400                                 const struct objfile *objfile)
401 {
402   struct objfile *res;
403
404   /* If any, return the first child.  */
405   res = objfile->separate_debug_objfile;
406   if (res)
407     return res;
408
409   /* Common case where there is no separate debug objfile.  */
410   if (objfile == parent)
411     return NULL;
412
413   /* Return the brother if any.  Note that we don't iterate on brothers of
414      the parents.  */
415   res = objfile->separate_debug_objfile_link;
416   if (res)
417     return res;
418
419   for (res = objfile->separate_debug_objfile_backlink;
420        res != parent;
421        res = res->separate_debug_objfile_backlink)
422     {
423       gdb_assert (res != NULL);
424       if (res->separate_debug_objfile_link)
425         return res->separate_debug_objfile_link;
426     }
427   return NULL;
428 }
429
430 /* Put one object file before a specified on in the global list.
431    This can be used to make sure an object file is destroyed before
432    another when using ALL_OBJFILES_SAFE to free all objfiles.  */
433 void
434 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
435 {
436   struct objfile **objp;
437
438   unlink_objfile (objfile);
439   
440   for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
441     {
442       if (*objp == before_this)
443         {
444           objfile->next = *objp;
445           *objp = objfile;
446           return;
447         }
448     }
449   
450   internal_error (__FILE__, __LINE__,
451                   _("put_objfile_before: before objfile not in list"));
452 }
453
454 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
455    list.
456
457    It is not a bug, or error, to call this function if OBJFILE is not known
458    to be in the current list.  This is done in the case of mapped objfiles,
459    for example, just to ensure that the mapped objfile doesn't appear twice
460    in the list.  Since the list is threaded, linking in a mapped objfile
461    twice would create a circular list.
462
463    If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
464    unlinking it, just to ensure that we have completely severed any linkages
465    between the OBJFILE and the list.  */
466
467 void
468 unlink_objfile (struct objfile *objfile)
469 {
470   struct objfile **objpp;
471
472   for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
473     {
474       if (*objpp == objfile)
475         {
476           *objpp = (*objpp)->next;
477           objfile->next = NULL;
478           return;
479         }
480     }
481
482   internal_error (__FILE__, __LINE__,
483                   _("unlink_objfile: objfile already unlinked"));
484 }
485
486 /* Add OBJFILE as a separate debug objfile of PARENT.  */
487
488 void
489 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
490 {
491   gdb_assert (objfile && parent);
492
493   /* Must not be already in a list.  */
494   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
495   gdb_assert (objfile->separate_debug_objfile_link == NULL);
496   gdb_assert (objfile->separate_debug_objfile == NULL);
497   gdb_assert (parent->separate_debug_objfile_backlink == NULL);
498   gdb_assert (parent->separate_debug_objfile_link == NULL);
499
500   objfile->separate_debug_objfile_backlink = parent;
501   objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
502   parent->separate_debug_objfile = objfile;
503
504   /* Put the separate debug object before the normal one, this is so that
505      usage of the ALL_OBJFILES_SAFE macro will stay safe.  */
506   put_objfile_before (objfile, parent);
507 }
508
509 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
510    itself.  */
511
512 void
513 free_objfile_separate_debug (struct objfile *objfile)
514 {
515   struct objfile *child;
516
517   for (child = objfile->separate_debug_objfile; child;)
518     {
519       struct objfile *next_child = child->separate_debug_objfile_link;
520       free_objfile (child);
521       child = next_child;
522     }
523 }
524
525 /* Destroy an objfile and all the symtabs and psymtabs under it.  */
526
527 void
528 free_objfile (struct objfile *objfile)
529 {
530   /* First notify observers that this objfile is about to be freed.  */
531   observer_notify_free_objfile (objfile);
532
533   /* Free all separate debug objfiles.  */
534   free_objfile_separate_debug (objfile);
535
536   if (objfile->separate_debug_objfile_backlink)
537     {
538       /* We freed the separate debug file, make sure the base objfile
539          doesn't reference it.  */
540       struct objfile *child;
541
542       child = objfile->separate_debug_objfile_backlink->separate_debug_objfile;
543
544       if (child == objfile)
545         {
546           /* OBJFILE is the first child.  */
547           objfile->separate_debug_objfile_backlink->separate_debug_objfile =
548             objfile->separate_debug_objfile_link;
549         }
550       else
551         {
552           /* Find OBJFILE in the list.  */
553           while (1)
554             {
555               if (child->separate_debug_objfile_link == objfile)
556                 {
557                   child->separate_debug_objfile_link =
558                     objfile->separate_debug_objfile_link;
559                   break;
560                 }
561               child = child->separate_debug_objfile_link;
562               gdb_assert (child);
563             }
564         }
565     }
566   
567   /* Remove any references to this objfile in the global value
568      lists.  */
569   preserve_values (objfile);
570
571   /* It still may reference data modules have associated with the objfile and
572      the symbol file data.  */
573   forget_cached_source_info_for_objfile (objfile);
574
575   breakpoint_free_objfile (objfile);
576   btrace_free_objfile (objfile);
577
578   /* First do any symbol file specific actions required when we are
579      finished with a particular symbol file.  Note that if the objfile
580      is using reusable symbol information (via mmalloc) then each of
581      these routines is responsible for doing the correct thing, either
582      freeing things which are valid only during this particular gdb
583      execution, or leaving them to be reused during the next one.  */
584
585   if (objfile->sf != NULL)
586     {
587       (*objfile->sf->sym_finish) (objfile);
588     }
589
590   /* Discard any data modules have associated with the objfile.  The function
591      still may reference objfile->obfd.  */
592   objfile_free_data (objfile);
593
594   if (objfile->obfd)
595     gdb_bfd_unref (objfile->obfd);
596   else
597     free_objfile_per_bfd_storage (objfile->per_bfd);
598
599   /* Remove it from the chain of all objfiles.  */
600
601   unlink_objfile (objfile);
602
603   if (objfile == symfile_objfile)
604     symfile_objfile = NULL;
605
606   /* Before the symbol table code was redone to make it easier to
607      selectively load and remove information particular to a specific
608      linkage unit, gdb used to do these things whenever the monolithic
609      symbol table was blown away.  How much still needs to be done
610      is unknown, but we play it safe for now and keep each action until
611      it is shown to be no longer needed.  */
612
613   /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
614      for example), so we need to call this here.  */
615   clear_pc_function_cache ();
616
617   /* Clear globals which might have pointed into a removed objfile.
618      FIXME: It's not clear which of these are supposed to persist
619      between expressions and which ought to be reset each time.  */
620   expression_context_block = NULL;
621   innermost_block = NULL;
622
623   /* Check to see if the current_source_symtab belongs to this objfile,
624      and if so, call clear_current_source_symtab_and_line.  */
625
626   {
627     struct symtab_and_line cursal = get_current_source_symtab_and_line ();
628
629     if (cursal.symtab && cursal.symtab->objfile == objfile)
630       clear_current_source_symtab_and_line ();
631   }
632
633   if (objfile->global_psymbols.list)
634     xfree (objfile->global_psymbols.list);
635   if (objfile->static_psymbols.list)
636     xfree (objfile->static_psymbols.list);
637   /* Free the obstacks for non-reusable objfiles.  */
638   psymbol_bcache_free (objfile->psymbol_cache);
639   obstack_free (&objfile->objfile_obstack, 0);
640
641   /* Rebuild section map next time we need it.  */
642   get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
643
644   /* The last thing we do is free the objfile struct itself.  */
645   xfree (objfile);
646 }
647
648 static void
649 do_free_objfile_cleanup (void *obj)
650 {
651   free_objfile (obj);
652 }
653
654 struct cleanup *
655 make_cleanup_free_objfile (struct objfile *obj)
656 {
657   return make_cleanup (do_free_objfile_cleanup, obj);
658 }
659
660 /* Free all the object files at once and clean up their users.  */
661
662 void
663 free_all_objfiles (void)
664 {
665   struct objfile *objfile, *temp;
666   struct so_list *so;
667
668   /* Any objfile referencewould become stale.  */
669   for (so = master_so_list (); so; so = so->next)
670     gdb_assert (so->objfile == NULL);
671
672   ALL_OBJFILES_SAFE (objfile, temp)
673   {
674     free_objfile (objfile);
675   }
676   clear_symtab_users (0);
677 }
678 \f
679 /* A helper function for objfile_relocate1 that relocates a single
680    symbol.  */
681
682 static void
683 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
684                      struct section_offsets *delta)
685 {
686   fixup_symbol_section (sym, objfile);
687
688   /* The RS6000 code from which this was taken skipped
689      any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
690      But I'm leaving out that test, on the theory that
691      they can't possibly pass the tests below.  */
692   if ((SYMBOL_CLASS (sym) == LOC_LABEL
693        || SYMBOL_CLASS (sym) == LOC_STATIC)
694       && SYMBOL_SECTION (sym) >= 0)
695     {
696       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
697     }
698 }
699
700 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
701    entries in new_offsets.  SEPARATE_DEBUG_OBJFILE is not touched here.
702    Return non-zero iff any change happened.  */
703
704 static int
705 objfile_relocate1 (struct objfile *objfile, 
706                    const struct section_offsets *new_offsets)
707 {
708   struct obj_section *s;
709   struct section_offsets *delta =
710     ((struct section_offsets *) 
711      alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
712
713   int i;
714   int something_changed = 0;
715
716   for (i = 0; i < objfile->num_sections; ++i)
717     {
718       delta->offsets[i] =
719         ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
720       if (ANOFFSET (delta, i) != 0)
721         something_changed = 1;
722     }
723   if (!something_changed)
724     return 0;
725
726   /* OK, get all the symtabs.  */
727   {
728     struct symtab *s;
729
730     ALL_OBJFILE_SYMTABS (objfile, s)
731     {
732       struct linetable *l;
733       struct blockvector *bv;
734       int i;
735
736       /* First the line table.  */
737       l = LINETABLE (s);
738       if (l)
739         {
740           for (i = 0; i < l->nitems; ++i)
741             l->item[i].pc += ANOFFSET (delta, s->block_line_section);
742         }
743
744       /* Don't relocate a shared blockvector more than once.  */
745       if (!s->primary)
746         continue;
747
748       bv = BLOCKVECTOR (s);
749       if (BLOCKVECTOR_MAP (bv))
750         addrmap_relocate (BLOCKVECTOR_MAP (bv),
751                           ANOFFSET (delta, s->block_line_section));
752
753       for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
754         {
755           struct block *b;
756           struct symbol *sym;
757           struct dict_iterator iter;
758
759           b = BLOCKVECTOR_BLOCK (bv, i);
760           BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
761           BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
762
763           /* We only want to iterate over the local symbols, not any
764              symbols in included symtabs.  */
765           ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
766             {
767               relocate_one_symbol (sym, objfile, delta);
768             }
769         }
770     }
771   }
772
773   /* Relocate isolated symbols.  */
774   {
775     struct symbol *iter;
776
777     for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
778       relocate_one_symbol (iter, objfile, delta);
779   }
780
781   if (objfile->psymtabs_addrmap)
782     addrmap_relocate (objfile->psymtabs_addrmap,
783                       ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
784
785   if (objfile->sf)
786     objfile->sf->qf->relocate (objfile, new_offsets, delta);
787
788   {
789     struct minimal_symbol *msym;
790
791     ALL_OBJFILE_MSYMBOLS (objfile, msym)
792       if (SYMBOL_SECTION (msym) >= 0)
793       SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
794   }
795   /* Relocating different sections by different amounts may cause the symbols
796      to be out of order.  */
797   msymbols_sort (objfile);
798
799   {
800     int i;
801
802     for (i = 0; i < objfile->num_sections; ++i)
803       (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
804   }
805
806   /* Rebuild section map next time we need it.  */
807   get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
808
809   /* Update the table in exec_ops, used to read memory.  */
810   ALL_OBJFILE_OSECTIONS (objfile, s)
811     {
812       int idx = s - objfile->sections;
813
814       exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
815                                 obj_section_addr (s));
816     }
817
818   /* Relocating probes.  */
819   if (objfile->sf && objfile->sf->sym_probe_fns)
820     objfile->sf->sym_probe_fns->sym_relocate_probe (objfile,
821                                                     new_offsets, delta);
822
823   /* Data changed.  */
824   return 1;
825 }
826
827 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
828    entries in new_offsets.  Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
829
830    The number and ordering of sections does differ between the two objfiles.
831    Only their names match.  Also the file offsets will differ (objfile being
832    possibly prelinked but separate_debug_objfile is probably not prelinked) but
833    the in-memory absolute address as specified by NEW_OFFSETS must match both
834    files.  */
835
836 void
837 objfile_relocate (struct objfile *objfile,
838                   const struct section_offsets *new_offsets)
839 {
840   struct objfile *debug_objfile;
841   int changed = 0;
842
843   changed |= objfile_relocate1 (objfile, new_offsets);
844
845   for (debug_objfile = objfile->separate_debug_objfile;
846        debug_objfile;
847        debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
848     {
849       struct section_addr_info *objfile_addrs;
850       struct section_offsets *new_debug_offsets;
851       struct cleanup *my_cleanups;
852
853       objfile_addrs = build_section_addr_info_from_objfile (objfile);
854       my_cleanups = make_cleanup (xfree, objfile_addrs);
855
856       /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
857          relative ones must be already created according to debug_objfile.  */
858
859       addr_info_make_relative (objfile_addrs, debug_objfile->obfd);
860
861       gdb_assert (debug_objfile->num_sections
862                   == gdb_bfd_count_sections (debug_objfile->obfd));
863       new_debug_offsets = 
864         xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
865       make_cleanup (xfree, new_debug_offsets);
866       relative_addr_info_to_section_offsets (new_debug_offsets,
867                                              debug_objfile->num_sections,
868                                              objfile_addrs);
869
870       changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
871
872       do_cleanups (my_cleanups);
873     }
874
875   /* Relocate breakpoints as necessary, after things are relocated.  */
876   if (changed)
877     breakpoint_re_set ();
878 }
879
880 /* Rebase (add to the offsets) OBJFILE by SLIDE.  SEPARATE_DEBUG_OBJFILE is
881    not touched here.
882    Return non-zero iff any change happened.  */
883
884 static int
885 objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
886 {
887   struct section_offsets *new_offsets =
888     ((struct section_offsets *)
889      alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
890   int i;
891
892   for (i = 0; i < objfile->num_sections; ++i)
893     new_offsets->offsets[i] = slide;
894
895   return objfile_relocate1 (objfile, new_offsets);
896 }
897
898 /* Rebase (add to the offsets) OBJFILE by SLIDE.  Process also OBJFILE's
899    SEPARATE_DEBUG_OBJFILEs.  */
900
901 void
902 objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
903 {
904   struct objfile *debug_objfile;
905   int changed = 0;
906
907   changed |= objfile_rebase1 (objfile, slide);
908
909   for (debug_objfile = objfile->separate_debug_objfile;
910        debug_objfile;
911        debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
912     changed |= objfile_rebase1 (debug_objfile, slide);
913
914   /* Relocate breakpoints as necessary, after things are relocated.  */
915   if (changed)
916     breakpoint_re_set ();
917 }
918 \f
919 /* Return non-zero if OBJFILE has partial symbols.  */
920
921 int
922 objfile_has_partial_symbols (struct objfile *objfile)
923 {
924   if (!objfile->sf)
925     return 0;
926
927   /* If we have not read psymbols, but we have a function capable of reading
928      them, then that is an indication that they are in fact available.  Without
929      this function the symbols may have been already read in but they also may
930      not be present in this objfile.  */
931   if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
932       && objfile->sf->sym_read_psymbols != NULL)
933     return 1;
934
935   return objfile->sf->qf->has_symbols (objfile);
936 }
937
938 /* Return non-zero if OBJFILE has full symbols.  */
939
940 int
941 objfile_has_full_symbols (struct objfile *objfile)
942 {
943   return objfile->symtabs != NULL;
944 }
945
946 /* Return non-zero if OBJFILE has full or partial symbols, either directly
947    or through a separate debug file.  */
948
949 int
950 objfile_has_symbols (struct objfile *objfile)
951 {
952   struct objfile *o;
953
954   for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
955     if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
956       return 1;
957   return 0;
958 }
959
960
961 /* Many places in gdb want to test just to see if we have any partial
962    symbols available.  This function returns zero if none are currently
963    available, nonzero otherwise.  */
964
965 int
966 have_partial_symbols (void)
967 {
968   struct objfile *ofp;
969
970   ALL_OBJFILES (ofp)
971   {
972     if (objfile_has_partial_symbols (ofp))
973       return 1;
974   }
975   return 0;
976 }
977
978 /* Many places in gdb want to test just to see if we have any full
979    symbols available.  This function returns zero if none are currently
980    available, nonzero otherwise.  */
981
982 int
983 have_full_symbols (void)
984 {
985   struct objfile *ofp;
986
987   ALL_OBJFILES (ofp)
988   {
989     if (objfile_has_full_symbols (ofp))
990       return 1;
991   }
992   return 0;
993 }
994
995
996 /* This operations deletes all objfile entries that represent solibs that
997    weren't explicitly loaded by the user, via e.g., the add-symbol-file
998    command.  */
999
1000 void
1001 objfile_purge_solibs (void)
1002 {
1003   struct objfile *objf;
1004   struct objfile *temp;
1005
1006   ALL_OBJFILES_SAFE (objf, temp)
1007   {
1008     /* We assume that the solib package has been purged already, or will
1009        be soon.  */
1010
1011     if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
1012       free_objfile (objf);
1013   }
1014 }
1015
1016
1017 /* Many places in gdb want to test just to see if we have any minimal
1018    symbols available.  This function returns zero if none are currently
1019    available, nonzero otherwise.  */
1020
1021 int
1022 have_minimal_symbols (void)
1023 {
1024   struct objfile *ofp;
1025
1026   ALL_OBJFILES (ofp)
1027   {
1028     if (ofp->minimal_symbol_count > 0)
1029       {
1030         return 1;
1031       }
1032   }
1033   return 0;
1034 }
1035
1036 /* Qsort comparison function.  */
1037
1038 static int
1039 qsort_cmp (const void *a, const void *b)
1040 {
1041   const struct obj_section *sect1 = *(const struct obj_section **) a;
1042   const struct obj_section *sect2 = *(const struct obj_section **) b;
1043   const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1044   const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1045
1046   if (sect1_addr < sect2_addr)
1047     return -1;
1048   else if (sect1_addr > sect2_addr)
1049     return 1;
1050   else
1051     {
1052       /* Sections are at the same address.  This could happen if
1053          A) we have an objfile and a separate debuginfo.
1054          B) we are confused, and have added sections without proper relocation,
1055          or something like that.  */
1056
1057       const struct objfile *const objfile1 = sect1->objfile;
1058       const struct objfile *const objfile2 = sect2->objfile;
1059
1060       if (objfile1->separate_debug_objfile == objfile2
1061           || objfile2->separate_debug_objfile == objfile1)
1062         {
1063           /* Case A.  The ordering doesn't matter: separate debuginfo files
1064              will be filtered out later.  */
1065
1066           return 0;
1067         }
1068
1069       /* Case B.  Maintain stable sort order, so bugs in GDB are easier to
1070          triage.  This section could be slow (since we iterate over all
1071          objfiles in each call to qsort_cmp), but this shouldn't happen
1072          very often (GDB is already in a confused state; one hopes this
1073          doesn't happen at all).  If you discover that significant time is
1074          spent in the loops below, do 'set complaints 100' and examine the
1075          resulting complaints.  */
1076
1077       if (objfile1 == objfile2)
1078         {
1079           /* Both sections came from the same objfile.  We are really confused.
1080              Sort on sequence order of sections within the objfile.  */
1081
1082           const struct obj_section *osect;
1083
1084           ALL_OBJFILE_OSECTIONS (objfile1, osect)
1085             if (osect == sect1)
1086               return -1;
1087             else if (osect == sect2)
1088               return 1;
1089
1090           /* We should have found one of the sections before getting here.  */
1091           gdb_assert_not_reached ("section not found");
1092         }
1093       else
1094         {
1095           /* Sort on sequence number of the objfile in the chain.  */
1096
1097           const struct objfile *objfile;
1098
1099           ALL_OBJFILES (objfile)
1100             if (objfile == objfile1)
1101               return -1;
1102             else if (objfile == objfile2)
1103               return 1;
1104
1105           /* We should have found one of the objfiles before getting here.  */
1106           gdb_assert_not_reached ("objfile not found");
1107         }
1108     }
1109
1110   /* Unreachable.  */
1111   gdb_assert_not_reached ("unexpected code path");
1112   return 0;
1113 }
1114
1115 /* Select "better" obj_section to keep.  We prefer the one that came from
1116    the real object, rather than the one from separate debuginfo.
1117    Most of the time the two sections are exactly identical, but with
1118    prelinking the .rel.dyn section in the real object may have different
1119    size.  */
1120
1121 static struct obj_section *
1122 preferred_obj_section (struct obj_section *a, struct obj_section *b)
1123 {
1124   gdb_assert (obj_section_addr (a) == obj_section_addr (b));
1125   gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
1126               || (b->objfile->separate_debug_objfile == a->objfile));
1127   gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
1128               || (b->objfile->separate_debug_objfile_backlink == a->objfile));
1129
1130   if (a->objfile->separate_debug_objfile != NULL)
1131     return a;
1132   return b;
1133 }
1134
1135 /* Return 1 if SECTION should be inserted into the section map.
1136    We want to insert only non-overlay and non-TLS section.  */
1137
1138 static int
1139 insert_section_p (const struct bfd *abfd,
1140                   const struct bfd_section *section)
1141 {
1142   const bfd_vma lma = bfd_section_lma (abfd, section);
1143
1144   if (overlay_debugging && lma != 0 && lma != bfd_section_vma (abfd, section)
1145       && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1146     /* This is an overlay section.  IN_MEMORY check is needed to avoid
1147        discarding sections from the "system supplied DSO" (aka vdso)
1148        on some Linux systems (e.g. Fedora 11).  */
1149     return 0;
1150   if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1151     /* This is a TLS section.  */
1152     return 0;
1153
1154   return 1;
1155 }
1156
1157 /* Filter out overlapping sections where one section came from the real
1158    objfile, and the other from a separate debuginfo file.
1159    Return the size of table after redundant sections have been eliminated.  */
1160
1161 static int
1162 filter_debuginfo_sections (struct obj_section **map, int map_size)
1163 {
1164   int i, j;
1165
1166   for (i = 0, j = 0; i < map_size - 1; i++)
1167     {
1168       struct obj_section *const sect1 = map[i];
1169       struct obj_section *const sect2 = map[i + 1];
1170       const struct objfile *const objfile1 = sect1->objfile;
1171       const struct objfile *const objfile2 = sect2->objfile;
1172       const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1173       const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1174
1175       if (sect1_addr == sect2_addr
1176           && (objfile1->separate_debug_objfile == objfile2
1177               || objfile2->separate_debug_objfile == objfile1))
1178         {
1179           map[j++] = preferred_obj_section (sect1, sect2);
1180           ++i;
1181         }
1182       else
1183         map[j++] = sect1;
1184     }
1185
1186   if (i < map_size)
1187     {
1188       gdb_assert (i == map_size - 1);
1189       map[j++] = map[i];
1190     }
1191
1192   /* The map should not have shrunk to less than half the original size.  */
1193   gdb_assert (map_size / 2 <= j);
1194
1195   return j;
1196 }
1197
1198 /* Filter out overlapping sections, issuing a warning if any are found.
1199    Overlapping sections could really be overlay sections which we didn't
1200    classify as such in insert_section_p, or we could be dealing with a
1201    corrupt binary.  */
1202
1203 static int
1204 filter_overlapping_sections (struct obj_section **map, int map_size)
1205 {
1206   int i, j;
1207
1208   for (i = 0, j = 0; i < map_size - 1; )
1209     {
1210       int k;
1211
1212       map[j++] = map[i];
1213       for (k = i + 1; k < map_size; k++)
1214         {
1215           struct obj_section *const sect1 = map[i];
1216           struct obj_section *const sect2 = map[k];
1217           const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1218           const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1219           const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1220
1221           gdb_assert (sect1_addr <= sect2_addr);
1222
1223           if (sect1_endaddr <= sect2_addr)
1224             break;
1225           else
1226             {
1227               /* We have an overlap.  Report it.  */
1228
1229               struct objfile *const objf1 = sect1->objfile;
1230               struct objfile *const objf2 = sect2->objfile;
1231
1232               const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1233               const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1234
1235               const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1236
1237               struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1238
1239               complaint (&symfile_complaints,
1240                          _("unexpected overlap between:\n"
1241                            " (A) section `%s' from `%s' [%s, %s)\n"
1242                            " (B) section `%s' from `%s' [%s, %s).\n"
1243                            "Will ignore section B"),
1244                          bfd_section_name (abfd1, bfds1), objfile_name (objf1),
1245                          paddress (gdbarch, sect1_addr),
1246                          paddress (gdbarch, sect1_endaddr),
1247                          bfd_section_name (abfd2, bfds2), objfile_name (objf2),
1248                          paddress (gdbarch, sect2_addr),
1249                          paddress (gdbarch, sect2_endaddr));
1250             }
1251         }
1252       i = k;
1253     }
1254
1255   if (i < map_size)
1256     {
1257       gdb_assert (i == map_size - 1);
1258       map[j++] = map[i];
1259     }
1260
1261   return j;
1262 }
1263
1264
1265 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1266    TLS, overlay and overlapping sections.  */
1267
1268 static void
1269 update_section_map (struct program_space *pspace,
1270                     struct obj_section ***pmap, int *pmap_size)
1271 {
1272   struct objfile_pspace_info *pspace_info;
1273   int alloc_size, map_size, i;
1274   struct obj_section *s, **map;
1275   struct objfile *objfile;
1276
1277   pspace_info = get_objfile_pspace_data (pspace);
1278   gdb_assert (pspace_info->section_map_dirty != 0
1279               || pspace_info->new_objfiles_available != 0);
1280
1281   map = *pmap;
1282   xfree (map);
1283
1284   alloc_size = 0;
1285   ALL_PSPACE_OBJFILES (pspace, objfile)
1286     ALL_OBJFILE_OSECTIONS (objfile, s)
1287       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1288         alloc_size += 1;
1289
1290   /* This happens on detach/attach (e.g. in gdb.base/attach.exp).  */
1291   if (alloc_size == 0)
1292     {
1293       *pmap = NULL;
1294       *pmap_size = 0;
1295       return;
1296     }
1297
1298   map = xmalloc (alloc_size * sizeof (*map));
1299
1300   i = 0;
1301   ALL_PSPACE_OBJFILES (pspace, objfile)
1302     ALL_OBJFILE_OSECTIONS (objfile, s)
1303       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1304         map[i++] = s;
1305
1306   qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1307   map_size = filter_debuginfo_sections(map, alloc_size);
1308   map_size = filter_overlapping_sections(map, map_size);
1309
1310   if (map_size < alloc_size)
1311     /* Some sections were eliminated.  Trim excess space.  */
1312     map = xrealloc (map, map_size * sizeof (*map));
1313   else
1314     gdb_assert (alloc_size == map_size);
1315
1316   *pmap = map;
1317   *pmap_size = map_size;
1318 }
1319
1320 /* Bsearch comparison function.  */
1321
1322 static int
1323 bsearch_cmp (const void *key, const void *elt)
1324 {
1325   const CORE_ADDR pc = *(CORE_ADDR *) key;
1326   const struct obj_section *section = *(const struct obj_section **) elt;
1327
1328   if (pc < obj_section_addr (section))
1329     return -1;
1330   if (pc < obj_section_endaddr (section))
1331     return 0;
1332   return 1;
1333 }
1334
1335 /* Returns a section whose range includes PC or NULL if none found.   */
1336
1337 struct obj_section *
1338 find_pc_section (CORE_ADDR pc)
1339 {
1340   struct objfile_pspace_info *pspace_info;
1341   struct obj_section *s, **sp;
1342
1343   /* Check for mapped overlay section first.  */
1344   s = find_pc_mapped_section (pc);
1345   if (s)
1346     return s;
1347
1348   pspace_info = get_objfile_pspace_data (current_program_space);
1349   if (pspace_info->section_map_dirty
1350       || (pspace_info->new_objfiles_available
1351           && !pspace_info->inhibit_updates))
1352     {
1353       update_section_map (current_program_space,
1354                           &pspace_info->sections,
1355                           &pspace_info->num_sections);
1356
1357       /* Don't need updates to section map until objfiles are added,
1358          removed or relocated.  */
1359       pspace_info->new_objfiles_available = 0;
1360       pspace_info->section_map_dirty = 0;
1361     }
1362
1363   /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1364      bsearch be non-NULL.  */
1365   if (pspace_info->sections == NULL)
1366     {
1367       gdb_assert (pspace_info->num_sections == 0);
1368       return NULL;
1369     }
1370
1371   sp = (struct obj_section **) bsearch (&pc,
1372                                         pspace_info->sections,
1373                                         pspace_info->num_sections,
1374                                         sizeof (*pspace_info->sections),
1375                                         bsearch_cmp);
1376   if (sp != NULL)
1377     return *sp;
1378   return NULL;
1379 }
1380
1381
1382 /* Return non-zero if PC is in a section called NAME.  */
1383
1384 int
1385 pc_in_section (CORE_ADDR pc, char *name)
1386 {
1387   struct obj_section *s;
1388   int retval = 0;
1389
1390   s = find_pc_section (pc);
1391
1392   retval = (s != NULL
1393             && s->the_bfd_section->name != NULL
1394             && strcmp (s->the_bfd_section->name, name) == 0);
1395   return (retval);
1396 }
1397 \f
1398
1399 /* Set section_map_dirty so section map will be rebuilt next time it
1400    is used.  Called by reread_symbols.  */
1401
1402 void
1403 objfiles_changed (void)
1404 {
1405   /* Rebuild section map next time we need it.  */
1406   get_objfile_pspace_data (current_program_space)->section_map_dirty = 1;
1407 }
1408
1409 /* See comments in objfiles.h.  */
1410
1411 void
1412 inhibit_section_map_updates (struct program_space *pspace)
1413 {
1414   get_objfile_pspace_data (pspace)->inhibit_updates = 1;
1415 }
1416
1417 /* See comments in objfiles.h.  */
1418
1419 void
1420 resume_section_map_updates (struct program_space *pspace)
1421 {
1422   get_objfile_pspace_data (pspace)->inhibit_updates = 0;
1423 }
1424
1425 /* See comments in objfiles.h.  */
1426
1427 void
1428 resume_section_map_updates_cleanup (void *arg)
1429 {
1430   resume_section_map_updates (arg);
1431 }
1432
1433 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1434    otherwise.  */
1435
1436 int
1437 is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile)
1438 {
1439   struct obj_section *osect;
1440
1441   if (objfile == NULL)
1442     return 0;
1443
1444   ALL_OBJFILE_OSECTIONS (objfile, osect)
1445     {
1446       if (section_is_overlay (osect) && !section_is_mapped (osect))
1447         continue;
1448
1449       if (obj_section_addr (osect) <= addr
1450           && addr < obj_section_endaddr (osect))
1451         return 1;
1452     }
1453   return 0;
1454 }
1455
1456 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1457    gdbarch method.  It is equivalent to use the ALL_OBJFILES macro,
1458    searching the objfiles in the order they are stored internally,
1459    ignoring CURRENT_OBJFILE.
1460
1461    On most platorms, it should be close enough to doing the best
1462    we can without some knowledge specific to the architecture.  */
1463
1464 void
1465 default_iterate_over_objfiles_in_search_order
1466   (struct gdbarch *gdbarch,
1467    iterate_over_objfiles_in_search_order_cb_ftype *cb,
1468    void *cb_data, struct objfile *current_objfile)
1469 {
1470   int stop = 0;
1471   struct objfile *objfile;
1472
1473   ALL_OBJFILES (objfile)
1474     {
1475        stop = cb (objfile, cb_data);
1476        if (stop)
1477          return;
1478     }
1479 }
1480
1481 /* Return canonical name for OBJFILE.  */
1482
1483 const char *
1484 objfile_name (const struct objfile *objfile)
1485 {
1486   if (objfile->obfd != NULL)
1487     return bfd_get_filename (objfile->obfd);
1488
1489   return objfile->original_name;
1490 }
1491
1492 /* Provide a prototype to silence -Wmissing-prototypes.  */
1493 extern initialize_file_ftype _initialize_objfiles;
1494
1495 void
1496 _initialize_objfiles (void)
1497 {
1498   objfiles_pspace_data
1499     = register_program_space_data_with_cleanup (NULL,
1500                                                 objfiles_pspace_data_cleanup);
1501
1502   objfiles_bfd_data = register_bfd_data_with_cleanup (NULL,
1503                                                       objfile_bfd_data_free);
1504 }