1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
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.
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.
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/>. */
22 /* This file contains support routines for creating, manipulating, and
23 destroying objfile structures. */
26 #include "bfd.h" /* Binary File Description */
30 #include "gdb-stabs.h"
33 #include "expression.h"
34 #include "parser-defs.h"
36 #include "gdb_assert.h"
37 #include <sys/types.h>
40 #include "gdb_obstack.h"
41 #include "gdb_string.h"
44 #include "breakpoint.h"
46 #include "dictionary.h"
49 #include "arch-utils.h"
52 #include "complaints.h"
58 /* Keep a registry of per-objfile data-pointers required by other GDB
61 DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
63 /* Externally visible variables that are owned by this module.
64 See declarations in objfile.h for more info. */
66 struct objfile *rt_common_objfile; /* For runtime common symbols */
68 struct objfile_pspace_info
70 int objfiles_changed_p;
71 struct obj_section **sections;
75 /* Per-program-space data key. */
76 static const struct program_space_data *objfiles_pspace_data;
79 objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
81 struct objfile_pspace_info *info;
83 info = program_space_data (pspace, objfiles_pspace_data);
86 xfree (info->sections);
91 /* Get the current svr4 data. If none is found yet, add it now. This
92 function always returns a valid object. */
94 static struct objfile_pspace_info *
95 get_objfile_pspace_data (struct program_space *pspace)
97 struct objfile_pspace_info *info;
99 info = program_space_data (pspace, objfiles_pspace_data);
102 info = XZALLOC (struct objfile_pspace_info);
103 set_program_space_data (pspace, objfiles_pspace_data, info);
111 /* Per-BFD data key. */
113 static const struct bfd_data *objfiles_bfd_data;
115 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
116 NULL, and it already has a per-BFD storage object, use that.
117 Otherwise, allocate a new per-BFD storage object. If ABFD is not
118 NULL, the object is allocated on the BFD; otherwise it is allocated
119 on OBJFILE's obstack. Note that it is not safe to call this
120 multiple times for a given OBJFILE -- it can only be called when
121 allocating or re-initializing OBJFILE. */
123 static struct objfile_per_bfd_storage *
124 get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
126 struct objfile_per_bfd_storage *storage = NULL;
129 storage = bfd_data (abfd, objfiles_bfd_data);
135 storage = bfd_zalloc (abfd, sizeof (struct objfile_per_bfd_storage));
136 set_bfd_data (abfd, objfiles_bfd_data, storage);
139 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
140 struct objfile_per_bfd_storage);
142 obstack_init (&storage->storage_obstack);
143 storage->filename_cache = bcache_xmalloc (NULL, NULL);
144 storage->macro_cache = bcache_xmalloc (NULL, NULL);
153 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage *storage)
155 bcache_xfree (storage->filename_cache);
156 bcache_xfree (storage->macro_cache);
157 obstack_free (&storage->storage_obstack, 0);
160 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
161 cleanup function to the BFD registry. */
164 objfile_bfd_data_free (struct bfd *unused, void *d)
166 free_objfile_per_bfd_storage (d);
169 /* See objfiles.h. */
172 set_objfile_per_bfd (struct objfile *objfile)
174 objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd);
179 /* Called via bfd_map_over_sections to build up the section table that
180 the objfile references. The objfile contains pointers to the start
181 of the table (objfile->sections) and to the first location after
182 the end of the table (objfile->sections_end). */
185 add_to_objfile_sections_full (struct bfd *abfd, struct bfd_section *asect,
186 struct objfile *objfile, int force)
188 struct obj_section *section;
194 aflag = bfd_get_section_flags (abfd, asect);
195 if (!(aflag & SEC_ALLOC))
199 section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
200 section->objfile = objfile;
201 section->the_bfd_section = asect;
202 section->ovly_mapped = 0;
206 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
209 add_to_objfile_sections_full (abfd, asect, objfilep, 0);
212 /* Builds a section table for OBJFILE.
214 Note that the OFFSET and OVLY_MAPPED in each table entry are
215 initialized to zero. */
218 build_objfile_section_table (struct objfile *objfile)
220 int count = gdb_bfd_count_sections (objfile->obfd);
222 objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
225 objfile->sections_end = (objfile->sections + count);
226 bfd_map_over_sections (objfile->obfd,
227 add_to_objfile_sections, (void *) objfile);
229 /* See gdb_bfd_section_index. */
230 add_to_objfile_sections_full (objfile->obfd, bfd_com_section_ptr, objfile, 1);
231 add_to_objfile_sections_full (objfile->obfd, bfd_und_section_ptr, objfile, 1);
232 add_to_objfile_sections_full (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
233 add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
236 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
237 allocate a new objfile struct, fill it in as best we can, link it
238 into the list of all known objfiles, and return a pointer to the
241 The FLAGS word contains various bits (OBJF_*) that can be taken as
242 requests for specific operations. Other bits like OBJF_SHARED are
243 simply copied through to the new objfile flags member. */
245 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
246 by jv-lang.c, to create an artificial objfile used to hold
247 information about dynamically-loaded Java classes. Unfortunately,
248 that branch of this function doesn't get tested very frequently, so
249 it's prone to breakage. (E.g. at one time the name was set to NULL
250 in that situation, which broke a loop over all names in the dynamic
251 library loader.) If you change this function, please try to leave
252 things in a consistent state even if abfd is NULL. */
255 allocate_objfile (bfd *abfd, int flags)
257 struct objfile *objfile;
259 objfile = (struct objfile *) xzalloc (sizeof (struct objfile));
260 objfile->psymbol_cache = psymbol_bcache_init ();
261 /* We could use obstack_specify_allocation here instead, but
262 gdb_obstack.h specifies the alloc/dealloc functions. */
263 obstack_init (&objfile->objfile_obstack);
264 terminate_minimal_symbol_table (objfile);
266 objfile_alloc_data (objfile);
268 /* Update the per-objfile information that comes from the bfd, ensuring
269 that any data that is reference is saved in the per-objfile data
272 objfile->obfd = abfd;
276 /* Look up the gdbarch associated with the BFD. */
277 objfile->gdbarch = gdbarch_from_bfd (abfd);
279 objfile->name = bfd_get_filename (abfd);
280 objfile->mtime = bfd_get_mtime (abfd);
282 /* Build section table. */
283 build_objfile_section_table (objfile);
287 objfile->name = "<<anonymous objfile>>";
290 objfile->per_bfd = get_objfile_bfd_data (objfile, abfd);
291 objfile->pspace = current_program_space;
293 /* Initialize the section indexes for this objfile, so that we can
294 later detect if they are used w/o being properly assigned to. */
296 objfile->sect_index_text = -1;
297 objfile->sect_index_data = -1;
298 objfile->sect_index_bss = -1;
299 objfile->sect_index_rodata = -1;
301 /* Add this file onto the tail of the linked list of other such files. */
303 objfile->next = NULL;
304 if (object_files == NULL)
305 object_files = objfile;
308 struct objfile *last_one;
310 for (last_one = object_files;
312 last_one = last_one->next);
313 last_one->next = objfile;
316 /* Save passed in flag bits. */
317 objfile->flags |= flags;
319 /* Rebuild section map next time we need it. */
320 get_objfile_pspace_data (objfile->pspace)->objfiles_changed_p = 1;
325 /* Retrieve the gdbarch associated with OBJFILE. */
327 get_objfile_arch (struct objfile *objfile)
329 return objfile->gdbarch;
332 /* If there is a valid and known entry point, function fills *ENTRY_P with it
333 and returns non-zero; otherwise it returns zero. */
336 entry_point_address_query (CORE_ADDR *entry_p)
338 if (symfile_objfile == NULL || !symfile_objfile->ei.entry_point_p)
341 *entry_p = symfile_objfile->ei.entry_point;
346 /* Get current entry point address. Call error if it is not known. */
349 entry_point_address (void)
353 if (!entry_point_address_query (&retval))
354 error (_("Entry point address is not known."));
359 /* Iterator on PARENT and every separate debug objfile of PARENT.
360 The usage pattern is:
361 for (objfile = parent;
363 objfile = objfile_separate_debug_iterate (parent, objfile))
368 objfile_separate_debug_iterate (const struct objfile *parent,
369 const struct objfile *objfile)
373 /* If any, return the first child. */
374 res = objfile->separate_debug_objfile;
378 /* Common case where there is no separate debug objfile. */
379 if (objfile == parent)
382 /* Return the brother if any. Note that we don't iterate on brothers of
384 res = objfile->separate_debug_objfile_link;
388 for (res = objfile->separate_debug_objfile_backlink;
390 res = res->separate_debug_objfile_backlink)
392 gdb_assert (res != NULL);
393 if (res->separate_debug_objfile_link)
394 return res->separate_debug_objfile_link;
399 /* Put one object file before a specified on in the global list.
400 This can be used to make sure an object file is destroyed before
401 another when using ALL_OBJFILES_SAFE to free all objfiles. */
403 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
405 struct objfile **objp;
407 unlink_objfile (objfile);
409 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
411 if (*objp == before_this)
413 objfile->next = *objp;
419 internal_error (__FILE__, __LINE__,
420 _("put_objfile_before: before objfile not in list"));
423 /* Put OBJFILE at the front of the list. */
426 objfile_to_front (struct objfile *objfile)
428 struct objfile **objp;
429 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
431 if (*objp == objfile)
433 /* Unhook it from where it is. */
434 *objp = objfile->next;
435 /* Put it in the front. */
436 objfile->next = object_files;
437 object_files = objfile;
443 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
446 It is not a bug, or error, to call this function if OBJFILE is not known
447 to be in the current list. This is done in the case of mapped objfiles,
448 for example, just to ensure that the mapped objfile doesn't appear twice
449 in the list. Since the list is threaded, linking in a mapped objfile
450 twice would create a circular list.
452 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
453 unlinking it, just to ensure that we have completely severed any linkages
454 between the OBJFILE and the list. */
457 unlink_objfile (struct objfile *objfile)
459 struct objfile **objpp;
461 for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
463 if (*objpp == objfile)
465 *objpp = (*objpp)->next;
466 objfile->next = NULL;
471 internal_error (__FILE__, __LINE__,
472 _("unlink_objfile: objfile already unlinked"));
475 /* Add OBJFILE as a separate debug objfile of PARENT. */
478 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
480 gdb_assert (objfile && parent);
482 /* Must not be already in a list. */
483 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
484 gdb_assert (objfile->separate_debug_objfile_link == NULL);
485 gdb_assert (objfile->separate_debug_objfile == NULL);
486 gdb_assert (parent->separate_debug_objfile_backlink == NULL);
487 gdb_assert (parent->separate_debug_objfile_link == NULL);
489 objfile->separate_debug_objfile_backlink = parent;
490 objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
491 parent->separate_debug_objfile = objfile;
493 /* Put the separate debug object before the normal one, this is so that
494 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
495 put_objfile_before (objfile, parent);
498 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
502 free_objfile_separate_debug (struct objfile *objfile)
504 struct objfile *child;
506 for (child = objfile->separate_debug_objfile; child;)
508 struct objfile *next_child = child->separate_debug_objfile_link;
509 free_objfile (child);
514 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
515 that as much as possible is allocated on the objfile_obstack
516 so that the memory can be efficiently freed.
518 Things which we do NOT free because they are not in malloc'd memory
519 or not in memory specific to the objfile include:
523 FIXME: If the objfile is using reusable symbol information (via mmalloc),
524 then we need to take into account the fact that more than one process
525 may be using the symbol information at the same time (when mmalloc is
526 extended to support cooperative locking). When more than one process
527 is using the mapped symbol info, we need to be more careful about when
528 we free objects in the reusable area. */
531 free_objfile (struct objfile *objfile)
533 /* Free all separate debug objfiles. */
534 free_objfile_separate_debug (objfile);
536 if (objfile->separate_debug_objfile_backlink)
538 /* We freed the separate debug file, make sure the base objfile
539 doesn't reference it. */
540 struct objfile *child;
542 child = objfile->separate_debug_objfile_backlink->separate_debug_objfile;
544 if (child == objfile)
546 /* OBJFILE is the first child. */
547 objfile->separate_debug_objfile_backlink->separate_debug_objfile =
548 objfile->separate_debug_objfile_link;
552 /* Find OBJFILE in the list. */
555 if (child->separate_debug_objfile_link == objfile)
557 child->separate_debug_objfile_link =
558 objfile->separate_debug_objfile_link;
561 child = child->separate_debug_objfile_link;
567 /* Remove any references to this objfile in the global value
569 preserve_values (objfile);
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);
575 breakpoint_free_objfile (objfile);
576 btrace_free_objfile (objfile);
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. */
585 if (objfile->sf != NULL)
587 (*objfile->sf->sym_finish) (objfile);
590 /* Discard any data modules have associated with the objfile. The function
591 still may reference objfile->obfd. */
592 objfile_free_data (objfile);
595 gdb_bfd_unref (objfile->obfd);
597 free_objfile_per_bfd_storage (objfile->per_bfd);
599 /* Remove it from the chain of all objfiles. */
601 unlink_objfile (objfile);
603 if (objfile == symfile_objfile)
604 symfile_objfile = NULL;
606 if (objfile == rt_common_objfile)
607 rt_common_objfile = NULL;
609 /* Before the symbol table code was redone to make it easier to
610 selectively load and remove information particular to a specific
611 linkage unit, gdb used to do these things whenever the monolithic
612 symbol table was blown away. How much still needs to be done
613 is unknown, but we play it safe for now and keep each action until
614 it is shown to be no longer needed. */
616 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
617 for example), so we need to call this here. */
618 clear_pc_function_cache ();
620 /* Clear globals which might have pointed into a removed objfile.
621 FIXME: It's not clear which of these are supposed to persist
622 between expressions and which ought to be reset each time. */
623 expression_context_block = NULL;
624 innermost_block = NULL;
626 /* Check to see if the current_source_symtab belongs to this objfile,
627 and if so, call clear_current_source_symtab_and_line. */
630 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
632 if (cursal.symtab && cursal.symtab->objfile == objfile)
633 clear_current_source_symtab_and_line ();
636 /* The last thing we do is free the objfile struct itself. */
638 if (objfile->global_psymbols.list)
639 xfree (objfile->global_psymbols.list);
640 if (objfile->static_psymbols.list)
641 xfree (objfile->static_psymbols.list);
642 /* Free the obstacks for non-reusable objfiles. */
643 psymbol_bcache_free (objfile->psymbol_cache);
644 if (objfile->demangled_names_hash)
645 htab_delete (objfile->demangled_names_hash);
646 obstack_free (&objfile->objfile_obstack, 0);
648 /* Rebuild section map next time we need it. */
649 get_objfile_pspace_data (objfile->pspace)->objfiles_changed_p = 1;
655 do_free_objfile_cleanup (void *obj)
661 make_cleanup_free_objfile (struct objfile *obj)
663 return make_cleanup (do_free_objfile_cleanup, obj);
666 /* Free all the object files at once and clean up their users. */
669 free_all_objfiles (void)
671 struct objfile *objfile, *temp;
674 /* Any objfile referencewould become stale. */
675 for (so = master_so_list (); so; so = so->next)
676 gdb_assert (so->objfile == NULL);
678 ALL_OBJFILES_SAFE (objfile, temp)
680 free_objfile (objfile);
682 clear_symtab_users (0);
685 /* A helper function for objfile_relocate1 that relocates a single
689 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
690 struct section_offsets *delta)
692 fixup_symbol_section (sym, objfile);
694 /* The RS6000 code from which this was taken skipped
695 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
696 But I'm leaving out that test, on the theory that
697 they can't possibly pass the tests below. */
698 if ((SYMBOL_CLASS (sym) == LOC_LABEL
699 || SYMBOL_CLASS (sym) == LOC_STATIC)
700 && SYMBOL_SECTION (sym) >= 0)
702 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
706 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
707 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
708 Return non-zero iff any change happened. */
711 objfile_relocate1 (struct objfile *objfile,
712 const struct section_offsets *new_offsets)
714 struct obj_section *s;
715 struct section_offsets *delta =
716 ((struct section_offsets *)
717 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
720 int something_changed = 0;
722 for (i = 0; i < objfile->num_sections; ++i)
725 ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
726 if (ANOFFSET (delta, i) != 0)
727 something_changed = 1;
729 if (!something_changed)
732 /* OK, get all the symtabs. */
736 ALL_OBJFILE_SYMTABS (objfile, s)
739 struct blockvector *bv;
742 /* First the line table. */
746 for (i = 0; i < l->nitems; ++i)
747 l->item[i].pc += ANOFFSET (delta, s->block_line_section);
750 /* Don't relocate a shared blockvector more than once. */
754 bv = BLOCKVECTOR (s);
755 if (BLOCKVECTOR_MAP (bv))
756 addrmap_relocate (BLOCKVECTOR_MAP (bv),
757 ANOFFSET (delta, s->block_line_section));
759 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
763 struct dict_iterator iter;
765 b = BLOCKVECTOR_BLOCK (bv, i);
766 BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
767 BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
769 /* We only want to iterate over the local symbols, not any
770 symbols in included symtabs. */
771 ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
773 relocate_one_symbol (sym, objfile, delta);
779 /* Relocate isolated symbols. */
783 for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
784 relocate_one_symbol (iter, objfile, delta);
787 if (objfile->psymtabs_addrmap)
788 addrmap_relocate (objfile->psymtabs_addrmap,
789 ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
792 objfile->sf->qf->relocate (objfile, new_offsets, delta);
795 struct minimal_symbol *msym;
797 ALL_OBJFILE_MSYMBOLS (objfile, msym)
798 if (SYMBOL_SECTION (msym) >= 0)
799 SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
801 /* Relocating different sections by different amounts may cause the symbols
802 to be out of order. */
803 msymbols_sort (objfile);
805 if (objfile->ei.entry_point_p)
807 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
808 only as a fallback. */
809 struct obj_section *s;
810 s = find_pc_section (objfile->ei.entry_point);
813 int idx = gdb_bfd_section_index (objfile->obfd, s->the_bfd_section);
815 objfile->ei.entry_point += ANOFFSET (delta, idx);
818 objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
824 for (i = 0; i < objfile->num_sections; ++i)
825 (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
828 /* Rebuild section map next time we need it. */
829 get_objfile_pspace_data (objfile->pspace)->objfiles_changed_p = 1;
831 /* Update the table in exec_ops, used to read memory. */
832 ALL_OBJFILE_OSECTIONS (objfile, s)
834 int idx = s - objfile->sections;
836 exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
837 obj_section_addr (s));
840 /* Relocating probes. */
841 if (objfile->sf && objfile->sf->sym_probe_fns)
842 objfile->sf->sym_probe_fns->sym_relocate_probe (objfile,
849 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
850 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
852 The number and ordering of sections does differ between the two objfiles.
853 Only their names match. Also the file offsets will differ (objfile being
854 possibly prelinked but separate_debug_objfile is probably not prelinked) but
855 the in-memory absolute address as specified by NEW_OFFSETS must match both
859 objfile_relocate (struct objfile *objfile,
860 const struct section_offsets *new_offsets)
862 struct objfile *debug_objfile;
865 changed |= objfile_relocate1 (objfile, new_offsets);
867 for (debug_objfile = objfile->separate_debug_objfile;
869 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
871 struct section_addr_info *objfile_addrs;
872 struct section_offsets *new_debug_offsets;
873 struct cleanup *my_cleanups;
875 objfile_addrs = build_section_addr_info_from_objfile (objfile);
876 my_cleanups = make_cleanup (xfree, objfile_addrs);
878 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
879 relative ones must be already created according to debug_objfile. */
881 addr_info_make_relative (objfile_addrs, debug_objfile->obfd);
883 gdb_assert (debug_objfile->num_sections
884 == gdb_bfd_count_sections (debug_objfile->obfd));
886 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
887 make_cleanup (xfree, new_debug_offsets);
888 relative_addr_info_to_section_offsets (new_debug_offsets,
889 debug_objfile->num_sections,
892 changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
894 do_cleanups (my_cleanups);
897 /* Relocate breakpoints as necessary, after things are relocated. */
899 breakpoint_re_set ();
902 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
904 Return non-zero iff any change happened. */
907 objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
909 struct section_offsets *new_offsets =
910 ((struct section_offsets *)
911 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
914 for (i = 0; i < objfile->num_sections; ++i)
915 new_offsets->offsets[i] = slide;
917 return objfile_relocate1 (objfile, new_offsets);
920 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
921 SEPARATE_DEBUG_OBJFILEs. */
924 objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
926 struct objfile *debug_objfile;
929 changed |= objfile_rebase1 (objfile, slide);
931 for (debug_objfile = objfile->separate_debug_objfile;
933 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
934 changed |= objfile_rebase1 (debug_objfile, slide);
936 /* Relocate breakpoints as necessary, after things are relocated. */
938 breakpoint_re_set ();
941 /* Return non-zero if OBJFILE has partial symbols. */
944 objfile_has_partial_symbols (struct objfile *objfile)
949 /* If we have not read psymbols, but we have a function capable of reading
950 them, then that is an indication that they are in fact available. Without
951 this function the symbols may have been already read in but they also may
952 not be present in this objfile. */
953 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
954 && objfile->sf->sym_read_psymbols != NULL)
957 return objfile->sf->qf->has_symbols (objfile);
960 /* Return non-zero if OBJFILE has full symbols. */
963 objfile_has_full_symbols (struct objfile *objfile)
965 return objfile->symtabs != NULL;
968 /* Return non-zero if OBJFILE has full or partial symbols, either directly
969 or through a separate debug file. */
972 objfile_has_symbols (struct objfile *objfile)
976 for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
977 if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
983 /* Many places in gdb want to test just to see if we have any partial
984 symbols available. This function returns zero if none are currently
985 available, nonzero otherwise. */
988 have_partial_symbols (void)
994 if (objfile_has_partial_symbols (ofp))
1000 /* Many places in gdb want to test just to see if we have any full
1001 symbols available. This function returns zero if none are currently
1002 available, nonzero otherwise. */
1005 have_full_symbols (void)
1007 struct objfile *ofp;
1011 if (objfile_has_full_symbols (ofp))
1018 /* This operations deletes all objfile entries that represent solibs that
1019 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1023 objfile_purge_solibs (void)
1025 struct objfile *objf;
1026 struct objfile *temp;
1028 ALL_OBJFILES_SAFE (objf, temp)
1030 /* We assume that the solib package has been purged already, or will
1033 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
1034 free_objfile (objf);
1039 /* Many places in gdb want to test just to see if we have any minimal
1040 symbols available. This function returns zero if none are currently
1041 available, nonzero otherwise. */
1044 have_minimal_symbols (void)
1046 struct objfile *ofp;
1050 if (ofp->minimal_symbol_count > 0)
1058 /* Qsort comparison function. */
1061 qsort_cmp (const void *a, const void *b)
1063 const struct obj_section *sect1 = *(const struct obj_section **) a;
1064 const struct obj_section *sect2 = *(const struct obj_section **) b;
1065 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1066 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1068 if (sect1_addr < sect2_addr)
1070 else if (sect1_addr > sect2_addr)
1074 /* Sections are at the same address. This could happen if
1075 A) we have an objfile and a separate debuginfo.
1076 B) we are confused, and have added sections without proper relocation,
1077 or something like that. */
1079 const struct objfile *const objfile1 = sect1->objfile;
1080 const struct objfile *const objfile2 = sect2->objfile;
1082 if (objfile1->separate_debug_objfile == objfile2
1083 || objfile2->separate_debug_objfile == objfile1)
1085 /* Case A. The ordering doesn't matter: separate debuginfo files
1086 will be filtered out later. */
1091 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1092 triage. This section could be slow (since we iterate over all
1093 objfiles in each call to qsort_cmp), but this shouldn't happen
1094 very often (GDB is already in a confused state; one hopes this
1095 doesn't happen at all). If you discover that significant time is
1096 spent in the loops below, do 'set complaints 100' and examine the
1097 resulting complaints. */
1099 if (objfile1 == objfile2)
1101 /* Both sections came from the same objfile. We are really confused.
1102 Sort on sequence order of sections within the objfile. */
1104 const struct obj_section *osect;
1106 ALL_OBJFILE_OSECTIONS (objfile1, osect)
1109 else if (osect == sect2)
1112 /* We should have found one of the sections before getting here. */
1113 gdb_assert_not_reached ("section not found");
1117 /* Sort on sequence number of the objfile in the chain. */
1119 const struct objfile *objfile;
1121 ALL_OBJFILES (objfile)
1122 if (objfile == objfile1)
1124 else if (objfile == objfile2)
1127 /* We should have found one of the objfiles before getting here. */
1128 gdb_assert_not_reached ("objfile not found");
1133 gdb_assert_not_reached ("unexpected code path");
1137 /* Select "better" obj_section to keep. We prefer the one that came from
1138 the real object, rather than the one from separate debuginfo.
1139 Most of the time the two sections are exactly identical, but with
1140 prelinking the .rel.dyn section in the real object may have different
1143 static struct obj_section *
1144 preferred_obj_section (struct obj_section *a, struct obj_section *b)
1146 gdb_assert (obj_section_addr (a) == obj_section_addr (b));
1147 gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
1148 || (b->objfile->separate_debug_objfile == a->objfile));
1149 gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
1150 || (b->objfile->separate_debug_objfile_backlink == a->objfile));
1152 if (a->objfile->separate_debug_objfile != NULL)
1157 /* Return 1 if SECTION should be inserted into the section map.
1158 We want to insert only non-overlay and non-TLS section. */
1161 insert_section_p (const struct bfd *abfd,
1162 const struct bfd_section *section)
1164 const bfd_vma lma = bfd_section_lma (abfd, section);
1166 if (overlay_debugging && lma != 0 && lma != bfd_section_vma (abfd, section)
1167 && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1168 /* This is an overlay section. IN_MEMORY check is needed to avoid
1169 discarding sections from the "system supplied DSO" (aka vdso)
1170 on some Linux systems (e.g. Fedora 11). */
1172 if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1173 /* This is a TLS section. */
1179 /* Filter out overlapping sections where one section came from the real
1180 objfile, and the other from a separate debuginfo file.
1181 Return the size of table after redundant sections have been eliminated. */
1184 filter_debuginfo_sections (struct obj_section **map, int map_size)
1188 for (i = 0, j = 0; i < map_size - 1; i++)
1190 struct obj_section *const sect1 = map[i];
1191 struct obj_section *const sect2 = map[i + 1];
1192 const struct objfile *const objfile1 = sect1->objfile;
1193 const struct objfile *const objfile2 = sect2->objfile;
1194 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1195 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1197 if (sect1_addr == sect2_addr
1198 && (objfile1->separate_debug_objfile == objfile2
1199 || objfile2->separate_debug_objfile == objfile1))
1201 map[j++] = preferred_obj_section (sect1, sect2);
1210 gdb_assert (i == map_size - 1);
1214 /* The map should not have shrunk to less than half the original size. */
1215 gdb_assert (map_size / 2 <= j);
1220 /* Filter out overlapping sections, issuing a warning if any are found.
1221 Overlapping sections could really be overlay sections which we didn't
1222 classify as such in insert_section_p, or we could be dealing with a
1226 filter_overlapping_sections (struct obj_section **map, int map_size)
1230 for (i = 0, j = 0; i < map_size - 1; )
1235 for (k = i + 1; k < map_size; k++)
1237 struct obj_section *const sect1 = map[i];
1238 struct obj_section *const sect2 = map[k];
1239 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1240 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1241 const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1243 gdb_assert (sect1_addr <= sect2_addr);
1245 if (sect1_endaddr <= sect2_addr)
1249 /* We have an overlap. Report it. */
1251 struct objfile *const objf1 = sect1->objfile;
1252 struct objfile *const objf2 = sect2->objfile;
1254 const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1255 const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1257 const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1259 struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1261 complaint (&symfile_complaints,
1262 _("unexpected overlap between:\n"
1263 " (A) section `%s' from `%s' [%s, %s)\n"
1264 " (B) section `%s' from `%s' [%s, %s).\n"
1265 "Will ignore section B"),
1266 bfd_section_name (abfd1, bfds1), objf1->name,
1267 paddress (gdbarch, sect1_addr),
1268 paddress (gdbarch, sect1_endaddr),
1269 bfd_section_name (abfd2, bfds2), objf2->name,
1270 paddress (gdbarch, sect2_addr),
1271 paddress (gdbarch, sect2_endaddr));
1279 gdb_assert (i == map_size - 1);
1287 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1288 TLS, overlay and overlapping sections. */
1291 update_section_map (struct program_space *pspace,
1292 struct obj_section ***pmap, int *pmap_size)
1294 int alloc_size, map_size, i;
1295 struct obj_section *s, **map;
1296 struct objfile *objfile;
1298 gdb_assert (get_objfile_pspace_data (pspace)->objfiles_changed_p != 0);
1304 ALL_PSPACE_OBJFILES (pspace, objfile)
1305 ALL_OBJFILE_OSECTIONS (objfile, s)
1306 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1309 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1310 if (alloc_size == 0)
1317 map = xmalloc (alloc_size * sizeof (*map));
1320 ALL_PSPACE_OBJFILES (pspace, objfile)
1321 ALL_OBJFILE_OSECTIONS (objfile, s)
1322 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1325 qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1326 map_size = filter_debuginfo_sections(map, alloc_size);
1327 map_size = filter_overlapping_sections(map, map_size);
1329 if (map_size < alloc_size)
1330 /* Some sections were eliminated. Trim excess space. */
1331 map = xrealloc (map, map_size * sizeof (*map));
1333 gdb_assert (alloc_size == map_size);
1336 *pmap_size = map_size;
1339 /* Bsearch comparison function. */
1342 bsearch_cmp (const void *key, const void *elt)
1344 const CORE_ADDR pc = *(CORE_ADDR *) key;
1345 const struct obj_section *section = *(const struct obj_section **) elt;
1347 if (pc < obj_section_addr (section))
1349 if (pc < obj_section_endaddr (section))
1354 /* Returns a section whose range includes PC or NULL if none found. */
1356 struct obj_section *
1357 find_pc_section (CORE_ADDR pc)
1359 struct objfile_pspace_info *pspace_info;
1360 struct obj_section *s, **sp;
1362 /* Check for mapped overlay section first. */
1363 s = find_pc_mapped_section (pc);
1367 pspace_info = get_objfile_pspace_data (current_program_space);
1368 if (pspace_info->objfiles_changed_p != 0)
1370 update_section_map (current_program_space,
1371 &pspace_info->sections,
1372 &pspace_info->num_sections);
1374 /* Don't need updates to section map until objfiles are added,
1375 removed or relocated. */
1376 pspace_info->objfiles_changed_p = 0;
1379 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1380 bsearch be non-NULL. */
1381 if (pspace_info->sections == NULL)
1383 gdb_assert (pspace_info->num_sections == 0);
1387 sp = (struct obj_section **) bsearch (&pc,
1388 pspace_info->sections,
1389 pspace_info->num_sections,
1390 sizeof (*pspace_info->sections),
1398 /* In SVR4, we recognize a trampoline by it's section name.
1399 That is, if the pc is in a section named ".plt" then we are in
1403 in_plt_section (CORE_ADDR pc, char *name)
1405 struct obj_section *s;
1408 s = find_pc_section (pc);
1411 && s->the_bfd_section->name != NULL
1412 && strcmp (s->the_bfd_section->name, ".plt") == 0);
1417 /* Set objfiles_changed_p so section map will be rebuilt next time it
1418 is used. Called by reread_symbols. */
1421 objfiles_changed (void)
1423 /* Rebuild section map next time we need it. */
1424 get_objfile_pspace_data (current_program_space)->objfiles_changed_p = 1;
1427 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1428 gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
1429 searching the objfiles in the order they are stored internally,
1430 ignoring CURRENT_OBJFILE.
1432 On most platorms, it should be close enough to doing the best
1433 we can without some knowledge specific to the architecture. */
1436 default_iterate_over_objfiles_in_search_order
1437 (struct gdbarch *gdbarch,
1438 iterate_over_objfiles_in_search_order_cb_ftype *cb,
1439 void *cb_data, struct objfile *current_objfile)
1442 struct objfile *objfile;
1444 ALL_OBJFILES (objfile)
1446 stop = cb (objfile, cb_data);
1452 /* Provide a prototype to silence -Wmissing-prototypes. */
1453 extern initialize_file_ftype _initialize_objfiles;
1456 _initialize_objfiles (void)
1458 objfiles_pspace_data
1459 = register_program_space_data_with_cleanup (NULL,
1460 objfiles_pspace_data_cleanup);
1462 objfiles_bfd_data = register_bfd_data_with_cleanup (NULL,
1463 objfile_bfd_data_free);