1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992-2014 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 <sys/types.h>
39 #include "gdb_obstack.h"
42 #include "breakpoint.h"
44 #include "dictionary.h"
47 #include "arch-utils.h"
50 #include "complaints.h"
56 /* Keep a registry of per-objfile data-pointers required by other GDB
59 DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
61 /* Externally visible variables that are owned by this module.
62 See declarations in objfile.h for more info. */
64 struct objfile_pspace_info
66 struct obj_section **sections;
69 /* Nonzero if object files have been added since the section map
71 int new_objfiles_available;
73 /* Nonzero if the section map MUST be updated before use. */
74 int section_map_dirty;
76 /* Nonzero if section map updates should be inhibited if possible. */
80 /* Per-program-space data key. */
81 static const struct program_space_data *objfiles_pspace_data;
84 objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
86 struct objfile_pspace_info *info = arg;
88 xfree (info->sections);
92 /* Get the current svr4 data. If none is found yet, add it now. This
93 function always returns a valid object. */
95 static struct objfile_pspace_info *
96 get_objfile_pspace_data (struct program_space *pspace)
98 struct objfile_pspace_info *info;
100 info = program_space_data (pspace, objfiles_pspace_data);
103 info = XCNEW (struct objfile_pspace_info);
104 set_program_space_data (pspace, objfiles_pspace_data, info);
112 /* Per-BFD data key. */
114 static const struct bfd_data *objfiles_bfd_data;
116 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
117 NULL, and it already has a per-BFD storage object, use that.
118 Otherwise, allocate a new per-BFD storage object. If ABFD is not
119 NULL, the object is allocated on the BFD; otherwise it is allocated
120 on OBJFILE's obstack. Note that it is not safe to call this
121 multiple times for a given OBJFILE -- it can only be called when
122 allocating or re-initializing OBJFILE. */
124 static struct objfile_per_bfd_storage *
125 get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
127 struct objfile_per_bfd_storage *storage = NULL;
130 storage = bfd_data (abfd, objfiles_bfd_data);
134 /* If the object requires gdb to do relocations, we simply fall
135 back to not sharing data across users. These cases are rare
136 enough that this seems reasonable. */
137 if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
139 storage = bfd_zalloc (abfd, sizeof (struct objfile_per_bfd_storage));
140 set_bfd_data (abfd, objfiles_bfd_data, storage);
143 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
144 struct objfile_per_bfd_storage);
146 /* Look up the gdbarch associated with the BFD. */
148 storage->gdbarch = gdbarch_from_bfd (abfd);
150 obstack_init (&storage->storage_obstack);
151 storage->filename_cache = bcache_xmalloc (NULL, NULL);
152 storage->macro_cache = bcache_xmalloc (NULL, NULL);
153 storage->language_of_main = language_unknown;
162 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage *storage)
164 bcache_xfree (storage->filename_cache);
165 bcache_xfree (storage->macro_cache);
166 if (storage->demangled_names_hash)
167 htab_delete (storage->demangled_names_hash);
168 obstack_free (&storage->storage_obstack, 0);
171 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
172 cleanup function to the BFD registry. */
175 objfile_bfd_data_free (struct bfd *unused, void *d)
177 free_objfile_per_bfd_storage (d);
180 /* See objfiles.h. */
183 set_objfile_per_bfd (struct objfile *objfile)
185 objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd);
188 /* Set the objfile's per-BFD notion of the "main" name and
192 set_objfile_main_name (struct objfile *objfile,
193 const char *name, enum language lang)
195 if (objfile->per_bfd->name_of_main == NULL
196 || strcmp (objfile->per_bfd->name_of_main, name) != 0)
197 objfile->per_bfd->name_of_main
198 = obstack_copy0 (&objfile->per_bfd->storage_obstack, name, strlen (name));
199 objfile->per_bfd->language_of_main = lang;
204 /* Called via bfd_map_over_sections to build up the section table that
205 the objfile references. The objfile contains pointers to the start
206 of the table (objfile->sections) and to the first location after
207 the end of the table (objfile->sections_end). */
210 add_to_objfile_sections_full (struct bfd *abfd, struct bfd_section *asect,
211 struct objfile *objfile, int force)
213 struct obj_section *section;
219 aflag = bfd_get_section_flags (abfd, asect);
220 if (!(aflag & SEC_ALLOC))
224 section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
225 section->objfile = objfile;
226 section->the_bfd_section = asect;
227 section->ovly_mapped = 0;
231 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
234 add_to_objfile_sections_full (abfd, asect, objfilep, 0);
237 /* Builds a section table for OBJFILE.
239 Note that the OFFSET and OVLY_MAPPED in each table entry are
240 initialized to zero. */
243 build_objfile_section_table (struct objfile *objfile)
245 int count = gdb_bfd_count_sections (objfile->obfd);
247 objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
250 objfile->sections_end = (objfile->sections + count);
251 bfd_map_over_sections (objfile->obfd,
252 add_to_objfile_sections, (void *) objfile);
254 /* See gdb_bfd_section_index. */
255 add_to_objfile_sections_full (objfile->obfd, bfd_com_section_ptr, objfile, 1);
256 add_to_objfile_sections_full (objfile->obfd, bfd_und_section_ptr, objfile, 1);
257 add_to_objfile_sections_full (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
258 add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
261 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
262 allocate a new objfile struct, fill it in as best we can, link it
263 into the list of all known objfiles, and return a pointer to the
266 NAME should contain original non-canonicalized filename or other
267 identifier as entered by user. If there is no better source use
268 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
269 NAME content is copied into returned objfile.
271 The FLAGS word contains various bits (OBJF_*) that can be taken as
272 requests for specific operations. Other bits like OBJF_SHARED are
273 simply copied through to the new objfile flags member. */
275 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
276 by jv-lang.c, to create an artificial objfile used to hold
277 information about dynamically-loaded Java classes. Unfortunately,
278 that branch of this function doesn't get tested very frequently, so
279 it's prone to breakage. (E.g. at one time the name was set to NULL
280 in that situation, which broke a loop over all names in the dynamic
281 library loader.) If you change this function, please try to leave
282 things in a consistent state even if abfd is NULL. */
285 allocate_objfile (bfd *abfd, const char *name, int flags)
287 struct objfile *objfile;
290 objfile = (struct objfile *) xzalloc (sizeof (struct objfile));
291 objfile->psymbol_cache = psymbol_bcache_init ();
292 /* We could use obstack_specify_allocation here instead, but
293 gdb_obstack.h specifies the alloc/dealloc functions. */
294 obstack_init (&objfile->objfile_obstack);
296 objfile_alloc_data (objfile);
300 gdb_assert (abfd == NULL);
301 gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
302 expanded_name = xstrdup ("<<anonymous objfile>>");
304 else if ((flags & OBJF_NOT_FILENAME) != 0)
305 expanded_name = xstrdup (name);
307 expanded_name = gdb_abspath (name);
308 objfile->original_name = obstack_copy0 (&objfile->objfile_obstack,
310 strlen (expanded_name));
311 xfree (expanded_name);
313 /* Update the per-objfile information that comes from the bfd, ensuring
314 that any data that is reference is saved in the per-objfile data
317 /* Update the per-objfile information that comes from the bfd, ensuring
318 that any data that is reference is saved in the per-objfile data
321 objfile->obfd = abfd;
325 objfile->mtime = bfd_get_mtime (abfd);
327 /* Build section table. */
328 build_objfile_section_table (objfile);
331 objfile->per_bfd = get_objfile_bfd_data (objfile, abfd);
332 objfile->pspace = current_program_space;
334 terminate_minimal_symbol_table (objfile);
336 /* Initialize the section indexes for this objfile, so that we can
337 later detect if they are used w/o being properly assigned to. */
339 objfile->sect_index_text = -1;
340 objfile->sect_index_data = -1;
341 objfile->sect_index_bss = -1;
342 objfile->sect_index_rodata = -1;
344 /* Add this file onto the tail of the linked list of other such files. */
346 objfile->next = NULL;
347 if (object_files == NULL)
348 object_files = objfile;
351 struct objfile *last_one;
353 for (last_one = object_files;
355 last_one = last_one->next);
356 last_one->next = objfile;
359 /* Save passed in flag bits. */
360 objfile->flags |= flags;
362 /* Rebuild section map next time we need it. */
363 get_objfile_pspace_data (objfile->pspace)->new_objfiles_available = 1;
368 /* Retrieve the gdbarch associated with OBJFILE. */
370 get_objfile_arch (struct objfile *objfile)
372 return objfile->per_bfd->gdbarch;
375 /* If there is a valid and known entry point, function fills *ENTRY_P with it
376 and returns non-zero; otherwise it returns zero. */
379 entry_point_address_query (CORE_ADDR *entry_p)
381 if (symfile_objfile == NULL || !symfile_objfile->per_bfd->ei.entry_point_p)
384 *entry_p = (symfile_objfile->per_bfd->ei.entry_point
385 + ANOFFSET (symfile_objfile->section_offsets,
386 symfile_objfile->per_bfd->ei.the_bfd_section_index));
391 /* Get current entry point address. Call error if it is not known. */
394 entry_point_address (void)
398 if (!entry_point_address_query (&retval))
399 error (_("Entry point address is not known."));
404 /* Iterator on PARENT and every separate debug objfile of PARENT.
405 The usage pattern is:
406 for (objfile = parent;
408 objfile = objfile_separate_debug_iterate (parent, objfile))
413 objfile_separate_debug_iterate (const struct objfile *parent,
414 const struct objfile *objfile)
418 /* If any, return the first child. */
419 res = objfile->separate_debug_objfile;
423 /* Common case where there is no separate debug objfile. */
424 if (objfile == parent)
427 /* Return the brother if any. Note that we don't iterate on brothers of
429 res = objfile->separate_debug_objfile_link;
433 for (res = objfile->separate_debug_objfile_backlink;
435 res = res->separate_debug_objfile_backlink)
437 gdb_assert (res != NULL);
438 if (res->separate_debug_objfile_link)
439 return res->separate_debug_objfile_link;
444 /* Put one object file before a specified on in the global list.
445 This can be used to make sure an object file is destroyed before
446 another when using ALL_OBJFILES_SAFE to free all objfiles. */
448 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
450 struct objfile **objp;
452 unlink_objfile (objfile);
454 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
456 if (*objp == before_this)
458 objfile->next = *objp;
464 internal_error (__FILE__, __LINE__,
465 _("put_objfile_before: before objfile not in list"));
468 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
471 It is not a bug, or error, to call this function if OBJFILE is not known
472 to be in the current list. This is done in the case of mapped objfiles,
473 for example, just to ensure that the mapped objfile doesn't appear twice
474 in the list. Since the list is threaded, linking in a mapped objfile
475 twice would create a circular list.
477 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
478 unlinking it, just to ensure that we have completely severed any linkages
479 between the OBJFILE and the list. */
482 unlink_objfile (struct objfile *objfile)
484 struct objfile **objpp;
486 for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
488 if (*objpp == objfile)
490 *objpp = (*objpp)->next;
491 objfile->next = NULL;
496 internal_error (__FILE__, __LINE__,
497 _("unlink_objfile: objfile already unlinked"));
500 /* Add OBJFILE as a separate debug objfile of PARENT. */
503 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
505 gdb_assert (objfile && parent);
507 /* Must not be already in a list. */
508 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
509 gdb_assert (objfile->separate_debug_objfile_link == NULL);
510 gdb_assert (objfile->separate_debug_objfile == NULL);
511 gdb_assert (parent->separate_debug_objfile_backlink == NULL);
512 gdb_assert (parent->separate_debug_objfile_link == NULL);
514 objfile->separate_debug_objfile_backlink = parent;
515 objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
516 parent->separate_debug_objfile = objfile;
518 /* Put the separate debug object before the normal one, this is so that
519 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
520 put_objfile_before (objfile, parent);
523 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
527 free_objfile_separate_debug (struct objfile *objfile)
529 struct objfile *child;
531 for (child = objfile->separate_debug_objfile; child;)
533 struct objfile *next_child = child->separate_debug_objfile_link;
534 free_objfile (child);
539 /* Destroy an objfile and all the symtabs and psymtabs under it. */
542 free_objfile (struct objfile *objfile)
544 /* First notify observers that this objfile is about to be freed. */
545 observer_notify_free_objfile (objfile);
547 /* Free all separate debug objfiles. */
548 free_objfile_separate_debug (objfile);
550 if (objfile->separate_debug_objfile_backlink)
552 /* We freed the separate debug file, make sure the base objfile
553 doesn't reference it. */
554 struct objfile *child;
556 child = objfile->separate_debug_objfile_backlink->separate_debug_objfile;
558 if (child == objfile)
560 /* OBJFILE is the first child. */
561 objfile->separate_debug_objfile_backlink->separate_debug_objfile =
562 objfile->separate_debug_objfile_link;
566 /* Find OBJFILE in the list. */
569 if (child->separate_debug_objfile_link == objfile)
571 child->separate_debug_objfile_link =
572 objfile->separate_debug_objfile_link;
575 child = child->separate_debug_objfile_link;
581 /* Remove any references to this objfile in the global value
583 preserve_values (objfile);
585 /* It still may reference data modules have associated with the objfile and
586 the symbol file data. */
587 forget_cached_source_info_for_objfile (objfile);
589 breakpoint_free_objfile (objfile);
590 btrace_free_objfile (objfile);
592 /* First do any symbol file specific actions required when we are
593 finished with a particular symbol file. Note that if the objfile
594 is using reusable symbol information (via mmalloc) then each of
595 these routines is responsible for doing the correct thing, either
596 freeing things which are valid only during this particular gdb
597 execution, or leaving them to be reused during the next one. */
599 if (objfile->sf != NULL)
601 (*objfile->sf->sym_finish) (objfile);
604 /* Discard any data modules have associated with the objfile. The function
605 still may reference objfile->obfd. */
606 objfile_free_data (objfile);
609 gdb_bfd_unref (objfile->obfd);
611 free_objfile_per_bfd_storage (objfile->per_bfd);
613 /* Remove it from the chain of all objfiles. */
615 unlink_objfile (objfile);
617 if (objfile == symfile_objfile)
618 symfile_objfile = NULL;
620 /* Before the symbol table code was redone to make it easier to
621 selectively load and remove information particular to a specific
622 linkage unit, gdb used to do these things whenever the monolithic
623 symbol table was blown away. How much still needs to be done
624 is unknown, but we play it safe for now and keep each action until
625 it is shown to be no longer needed. */
627 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
628 for example), so we need to call this here. */
629 clear_pc_function_cache ();
631 /* Clear globals which might have pointed into a removed objfile.
632 FIXME: It's not clear which of these are supposed to persist
633 between expressions and which ought to be reset each time. */
634 expression_context_block = NULL;
635 innermost_block = NULL;
637 /* Check to see if the current_source_symtab belongs to this objfile,
638 and if so, call clear_current_source_symtab_and_line. */
641 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
643 if (cursal.symtab && cursal.symtab->objfile == objfile)
644 clear_current_source_symtab_and_line ();
647 if (objfile->global_psymbols.list)
648 xfree (objfile->global_psymbols.list);
649 if (objfile->static_psymbols.list)
650 xfree (objfile->static_psymbols.list);
651 /* Free the obstacks for non-reusable objfiles. */
652 psymbol_bcache_free (objfile->psymbol_cache);
653 obstack_free (&objfile->objfile_obstack, 0);
655 /* Rebuild section map next time we need it. */
656 get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
658 /* The last thing we do is free the objfile struct itself. */
663 do_free_objfile_cleanup (void *obj)
669 make_cleanup_free_objfile (struct objfile *obj)
671 return make_cleanup (do_free_objfile_cleanup, obj);
674 /* Free all the object files at once and clean up their users. */
677 free_all_objfiles (void)
679 struct objfile *objfile, *temp;
682 /* Any objfile referencewould become stale. */
683 for (so = master_so_list (); so; so = so->next)
684 gdb_assert (so->objfile == NULL);
686 ALL_OBJFILES_SAFE (objfile, temp)
688 free_objfile (objfile);
690 clear_symtab_users (0);
693 /* A helper function for objfile_relocate1 that relocates a single
697 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
698 struct section_offsets *delta)
700 fixup_symbol_section (sym, objfile);
702 /* The RS6000 code from which this was taken skipped
703 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
704 But I'm leaving out that test, on the theory that
705 they can't possibly pass the tests below. */
706 if ((SYMBOL_CLASS (sym) == LOC_LABEL
707 || SYMBOL_CLASS (sym) == LOC_STATIC)
708 && SYMBOL_SECTION (sym) >= 0)
710 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
714 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
715 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
716 Return non-zero iff any change happened. */
719 objfile_relocate1 (struct objfile *objfile,
720 const struct section_offsets *new_offsets)
722 struct obj_section *s;
723 struct section_offsets *delta =
724 ((struct section_offsets *)
725 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
728 int something_changed = 0;
730 for (i = 0; i < objfile->num_sections; ++i)
733 ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
734 if (ANOFFSET (delta, i) != 0)
735 something_changed = 1;
737 if (!something_changed)
740 /* OK, get all the symtabs. */
744 ALL_OBJFILE_SYMTABS (objfile, s)
747 const struct blockvector *bv;
750 /* First the line table. */
754 for (i = 0; i < l->nitems; ++i)
755 l->item[i].pc += ANOFFSET (delta, s->block_line_section);
758 /* Don't relocate a shared blockvector more than once. */
762 bv = BLOCKVECTOR (s);
763 if (BLOCKVECTOR_MAP (bv))
764 addrmap_relocate (BLOCKVECTOR_MAP (bv),
765 ANOFFSET (delta, s->block_line_section));
767 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
771 struct dict_iterator iter;
773 b = BLOCKVECTOR_BLOCK (bv, i);
774 BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
775 BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
777 /* We only want to iterate over the local symbols, not any
778 symbols in included symtabs. */
779 ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
781 relocate_one_symbol (sym, objfile, delta);
787 /* Relocate isolated symbols. */
791 for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
792 relocate_one_symbol (iter, objfile, delta);
795 if (objfile->psymtabs_addrmap)
796 addrmap_relocate (objfile->psymtabs_addrmap,
797 ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
800 objfile->sf->qf->relocate (objfile, new_offsets, delta);
805 for (i = 0; i < objfile->num_sections; ++i)
806 (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
809 /* Rebuild section map next time we need it. */
810 get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
812 /* Update the table in exec_ops, used to read memory. */
813 ALL_OBJFILE_OSECTIONS (objfile, s)
815 int idx = s - objfile->sections;
817 exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
818 obj_section_addr (s));
825 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
826 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
828 The number and ordering of sections does differ between the two objfiles.
829 Only their names match. Also the file offsets will differ (objfile being
830 possibly prelinked but separate_debug_objfile is probably not prelinked) but
831 the in-memory absolute address as specified by NEW_OFFSETS must match both
835 objfile_relocate (struct objfile *objfile,
836 const struct section_offsets *new_offsets)
838 struct objfile *debug_objfile;
841 changed |= objfile_relocate1 (objfile, new_offsets);
843 for (debug_objfile = objfile->separate_debug_objfile;
845 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
847 struct section_addr_info *objfile_addrs;
848 struct section_offsets *new_debug_offsets;
849 struct cleanup *my_cleanups;
851 objfile_addrs = build_section_addr_info_from_objfile (objfile);
852 my_cleanups = make_cleanup (xfree, objfile_addrs);
854 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
855 relative ones must be already created according to debug_objfile. */
857 addr_info_make_relative (objfile_addrs, debug_objfile->obfd);
859 gdb_assert (debug_objfile->num_sections
860 == gdb_bfd_count_sections (debug_objfile->obfd));
862 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
863 make_cleanup (xfree, new_debug_offsets);
864 relative_addr_info_to_section_offsets (new_debug_offsets,
865 debug_objfile->num_sections,
868 changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
870 do_cleanups (my_cleanups);
873 /* Relocate breakpoints as necessary, after things are relocated. */
875 breakpoint_re_set ();
878 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
880 Return non-zero iff any change happened. */
883 objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
885 struct section_offsets *new_offsets =
886 ((struct section_offsets *)
887 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
890 for (i = 0; i < objfile->num_sections; ++i)
891 new_offsets->offsets[i] = slide;
893 return objfile_relocate1 (objfile, new_offsets);
896 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
897 SEPARATE_DEBUG_OBJFILEs. */
900 objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
902 struct objfile *debug_objfile;
905 changed |= objfile_rebase1 (objfile, slide);
907 for (debug_objfile = objfile->separate_debug_objfile;
909 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
910 changed |= objfile_rebase1 (debug_objfile, slide);
912 /* Relocate breakpoints as necessary, after things are relocated. */
914 breakpoint_re_set ();
917 /* Return non-zero if OBJFILE has partial symbols. */
920 objfile_has_partial_symbols (struct objfile *objfile)
925 /* If we have not read psymbols, but we have a function capable of reading
926 them, then that is an indication that they are in fact available. Without
927 this function the symbols may have been already read in but they also may
928 not be present in this objfile. */
929 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
930 && objfile->sf->sym_read_psymbols != NULL)
933 return objfile->sf->qf->has_symbols (objfile);
936 /* Return non-zero if OBJFILE has full symbols. */
939 objfile_has_full_symbols (struct objfile *objfile)
941 return objfile->symtabs != NULL;
944 /* Return non-zero if OBJFILE has full or partial symbols, either directly
945 or through a separate debug file. */
948 objfile_has_symbols (struct objfile *objfile)
952 for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
953 if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
959 /* Many places in gdb want to test just to see if we have any partial
960 symbols available. This function returns zero if none are currently
961 available, nonzero otherwise. */
964 have_partial_symbols (void)
970 if (objfile_has_partial_symbols (ofp))
976 /* Many places in gdb want to test just to see if we have any full
977 symbols available. This function returns zero if none are currently
978 available, nonzero otherwise. */
981 have_full_symbols (void)
987 if (objfile_has_full_symbols (ofp))
994 /* This operations deletes all objfile entries that represent solibs that
995 weren't explicitly loaded by the user, via e.g., the add-symbol-file
999 objfile_purge_solibs (void)
1001 struct objfile *objf;
1002 struct objfile *temp;
1004 ALL_OBJFILES_SAFE (objf, temp)
1006 /* We assume that the solib package has been purged already, or will
1009 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
1010 free_objfile (objf);
1015 /* Many places in gdb want to test just to see if we have any minimal
1016 symbols available. This function returns zero if none are currently
1017 available, nonzero otherwise. */
1020 have_minimal_symbols (void)
1022 struct objfile *ofp;
1026 if (ofp->per_bfd->minimal_symbol_count > 0)
1034 /* Qsort comparison function. */
1037 qsort_cmp (const void *a, const void *b)
1039 const struct obj_section *sect1 = *(const struct obj_section **) a;
1040 const struct obj_section *sect2 = *(const struct obj_section **) b;
1041 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1042 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1044 if (sect1_addr < sect2_addr)
1046 else if (sect1_addr > sect2_addr)
1050 /* Sections are at the same address. This could happen if
1051 A) we have an objfile and a separate debuginfo.
1052 B) we are confused, and have added sections without proper relocation,
1053 or something like that. */
1055 const struct objfile *const objfile1 = sect1->objfile;
1056 const struct objfile *const objfile2 = sect2->objfile;
1058 if (objfile1->separate_debug_objfile == objfile2
1059 || objfile2->separate_debug_objfile == objfile1)
1061 /* Case A. The ordering doesn't matter: separate debuginfo files
1062 will be filtered out later. */
1067 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1068 triage. This section could be slow (since we iterate over all
1069 objfiles in each call to qsort_cmp), but this shouldn't happen
1070 very often (GDB is already in a confused state; one hopes this
1071 doesn't happen at all). If you discover that significant time is
1072 spent in the loops below, do 'set complaints 100' and examine the
1073 resulting complaints. */
1075 if (objfile1 == objfile2)
1077 /* Both sections came from the same objfile. We are really confused.
1078 Sort on sequence order of sections within the objfile. */
1080 const struct obj_section *osect;
1082 ALL_OBJFILE_OSECTIONS (objfile1, osect)
1085 else if (osect == sect2)
1088 /* We should have found one of the sections before getting here. */
1089 gdb_assert_not_reached ("section not found");
1093 /* Sort on sequence number of the objfile in the chain. */
1095 const struct objfile *objfile;
1097 ALL_OBJFILES (objfile)
1098 if (objfile == objfile1)
1100 else if (objfile == objfile2)
1103 /* We should have found one of the objfiles before getting here. */
1104 gdb_assert_not_reached ("objfile not found");
1109 gdb_assert_not_reached ("unexpected code path");
1113 /* Select "better" obj_section to keep. We prefer the one that came from
1114 the real object, rather than the one from separate debuginfo.
1115 Most of the time the two sections are exactly identical, but with
1116 prelinking the .rel.dyn section in the real object may have different
1119 static struct obj_section *
1120 preferred_obj_section (struct obj_section *a, struct obj_section *b)
1122 gdb_assert (obj_section_addr (a) == obj_section_addr (b));
1123 gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
1124 || (b->objfile->separate_debug_objfile == a->objfile));
1125 gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
1126 || (b->objfile->separate_debug_objfile_backlink == a->objfile));
1128 if (a->objfile->separate_debug_objfile != NULL)
1133 /* Return 1 if SECTION should be inserted into the section map.
1134 We want to insert only non-overlay and non-TLS section. */
1137 insert_section_p (const struct bfd *abfd,
1138 const struct bfd_section *section)
1140 const bfd_vma lma = bfd_section_lma (abfd, section);
1142 if (overlay_debugging && lma != 0 && lma != bfd_section_vma (abfd, section)
1143 && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1144 /* This is an overlay section. IN_MEMORY check is needed to avoid
1145 discarding sections from the "system supplied DSO" (aka vdso)
1146 on some Linux systems (e.g. Fedora 11). */
1148 if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1149 /* This is a TLS section. */
1155 /* Filter out overlapping sections where one section came from the real
1156 objfile, and the other from a separate debuginfo file.
1157 Return the size of table after redundant sections have been eliminated. */
1160 filter_debuginfo_sections (struct obj_section **map, int map_size)
1164 for (i = 0, j = 0; i < map_size - 1; i++)
1166 struct obj_section *const sect1 = map[i];
1167 struct obj_section *const sect2 = map[i + 1];
1168 const struct objfile *const objfile1 = sect1->objfile;
1169 const struct objfile *const objfile2 = sect2->objfile;
1170 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1171 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1173 if (sect1_addr == sect2_addr
1174 && (objfile1->separate_debug_objfile == objfile2
1175 || objfile2->separate_debug_objfile == objfile1))
1177 map[j++] = preferred_obj_section (sect1, sect2);
1186 gdb_assert (i == map_size - 1);
1190 /* The map should not have shrunk to less than half the original size. */
1191 gdb_assert (map_size / 2 <= j);
1196 /* Filter out overlapping sections, issuing a warning if any are found.
1197 Overlapping sections could really be overlay sections which we didn't
1198 classify as such in insert_section_p, or we could be dealing with a
1202 filter_overlapping_sections (struct obj_section **map, int map_size)
1206 for (i = 0, j = 0; i < map_size - 1; )
1211 for (k = i + 1; k < map_size; k++)
1213 struct obj_section *const sect1 = map[i];
1214 struct obj_section *const sect2 = map[k];
1215 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1216 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1217 const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1219 gdb_assert (sect1_addr <= sect2_addr);
1221 if (sect1_endaddr <= sect2_addr)
1225 /* We have an overlap. Report it. */
1227 struct objfile *const objf1 = sect1->objfile;
1228 struct objfile *const objf2 = sect2->objfile;
1230 const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1231 const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1233 const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1235 struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1237 complaint (&symfile_complaints,
1238 _("unexpected overlap between:\n"
1239 " (A) section `%s' from `%s' [%s, %s)\n"
1240 " (B) section `%s' from `%s' [%s, %s).\n"
1241 "Will ignore section B"),
1242 bfd_section_name (abfd1, bfds1), objfile_name (objf1),
1243 paddress (gdbarch, sect1_addr),
1244 paddress (gdbarch, sect1_endaddr),
1245 bfd_section_name (abfd2, bfds2), objfile_name (objf2),
1246 paddress (gdbarch, sect2_addr),
1247 paddress (gdbarch, sect2_endaddr));
1255 gdb_assert (i == map_size - 1);
1263 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1264 TLS, overlay and overlapping sections. */
1267 update_section_map (struct program_space *pspace,
1268 struct obj_section ***pmap, int *pmap_size)
1270 struct objfile_pspace_info *pspace_info;
1271 int alloc_size, map_size, i;
1272 struct obj_section *s, **map;
1273 struct objfile *objfile;
1275 pspace_info = get_objfile_pspace_data (pspace);
1276 gdb_assert (pspace_info->section_map_dirty != 0
1277 || pspace_info->new_objfiles_available != 0);
1283 ALL_PSPACE_OBJFILES (pspace, objfile)
1284 ALL_OBJFILE_OSECTIONS (objfile, s)
1285 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1288 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1289 if (alloc_size == 0)
1296 map = xmalloc (alloc_size * sizeof (*map));
1299 ALL_PSPACE_OBJFILES (pspace, objfile)
1300 ALL_OBJFILE_OSECTIONS (objfile, s)
1301 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1304 qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1305 map_size = filter_debuginfo_sections(map, alloc_size);
1306 map_size = filter_overlapping_sections(map, map_size);
1308 if (map_size < alloc_size)
1309 /* Some sections were eliminated. Trim excess space. */
1310 map = xrealloc (map, map_size * sizeof (*map));
1312 gdb_assert (alloc_size == map_size);
1315 *pmap_size = map_size;
1318 /* Bsearch comparison function. */
1321 bsearch_cmp (const void *key, const void *elt)
1323 const CORE_ADDR pc = *(CORE_ADDR *) key;
1324 const struct obj_section *section = *(const struct obj_section **) elt;
1326 if (pc < obj_section_addr (section))
1328 if (pc < obj_section_endaddr (section))
1333 /* Returns a section whose range includes PC or NULL if none found. */
1335 struct obj_section *
1336 find_pc_section (CORE_ADDR pc)
1338 struct objfile_pspace_info *pspace_info;
1339 struct obj_section *s, **sp;
1341 /* Check for mapped overlay section first. */
1342 s = find_pc_mapped_section (pc);
1346 pspace_info = get_objfile_pspace_data (current_program_space);
1347 if (pspace_info->section_map_dirty
1348 || (pspace_info->new_objfiles_available
1349 && !pspace_info->inhibit_updates))
1351 update_section_map (current_program_space,
1352 &pspace_info->sections,
1353 &pspace_info->num_sections);
1355 /* Don't need updates to section map until objfiles are added,
1356 removed or relocated. */
1357 pspace_info->new_objfiles_available = 0;
1358 pspace_info->section_map_dirty = 0;
1361 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1362 bsearch be non-NULL. */
1363 if (pspace_info->sections == NULL)
1365 gdb_assert (pspace_info->num_sections == 0);
1369 sp = (struct obj_section **) bsearch (&pc,
1370 pspace_info->sections,
1371 pspace_info->num_sections,
1372 sizeof (*pspace_info->sections),
1380 /* Return non-zero if PC is in a section called NAME. */
1383 pc_in_section (CORE_ADDR pc, char *name)
1385 struct obj_section *s;
1388 s = find_pc_section (pc);
1391 && s->the_bfd_section->name != NULL
1392 && strcmp (s->the_bfd_section->name, name) == 0);
1397 /* Set section_map_dirty so section map will be rebuilt next time it
1398 is used. Called by reread_symbols. */
1401 objfiles_changed (void)
1403 /* Rebuild section map next time we need it. */
1404 get_objfile_pspace_data (current_program_space)->section_map_dirty = 1;
1407 /* See comments in objfiles.h. */
1410 inhibit_section_map_updates (struct program_space *pspace)
1412 get_objfile_pspace_data (pspace)->inhibit_updates = 1;
1415 /* See comments in objfiles.h. */
1418 resume_section_map_updates (struct program_space *pspace)
1420 get_objfile_pspace_data (pspace)->inhibit_updates = 0;
1423 /* See comments in objfiles.h. */
1426 resume_section_map_updates_cleanup (void *arg)
1428 resume_section_map_updates (arg);
1431 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1435 is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile)
1437 struct obj_section *osect;
1439 if (objfile == NULL)
1442 ALL_OBJFILE_OSECTIONS (objfile, osect)
1444 if (section_is_overlay (osect) && !section_is_mapped (osect))
1447 if (obj_section_addr (osect) <= addr
1448 && addr < obj_section_endaddr (osect))
1455 shared_objfile_contains_address_p (struct program_space *pspace,
1458 struct objfile *objfile;
1460 ALL_PSPACE_OBJFILES (pspace, objfile)
1462 if ((objfile->flags & OBJF_SHARED) != 0
1463 && is_addr_in_objfile (address, objfile))
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.
1475 On most platorms, it should be close enough to doing the best
1476 we can without some knowledge specific to the architecture. */
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)
1485 struct objfile *objfile;
1487 ALL_OBJFILES (objfile)
1489 stop = cb (objfile, cb_data);
1495 /* Return canonical name for OBJFILE. */
1498 objfile_name (const struct objfile *objfile)
1500 if (objfile->obfd != NULL)
1501 return bfd_get_filename (objfile->obfd);
1503 return objfile->original_name;
1506 /* Provide a prototype to silence -Wmissing-prototypes. */
1507 extern initialize_file_ftype _initialize_objfiles;
1510 _initialize_objfiles (void)
1512 objfiles_pspace_data
1513 = register_program_space_data_with_cleanup (NULL,
1514 objfiles_pspace_data_cleanup);
1516 objfiles_bfd_data = register_bfd_data_with_cleanup (NULL,
1517 objfile_bfd_data_free);