1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992-2019 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"
49 #include "observable.h"
50 #include "complaints.h"
55 #include "common/pathstuff.h"
59 /* Keep a registry of per-objfile data-pointers required by other GDB
62 DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
64 /* Externally visible variables that are owned by this module.
65 See declarations in objfile.h for more info. */
67 struct objfile_pspace_info
69 struct obj_section **sections;
72 /* Nonzero if object files have been added since the section map
74 int new_objfiles_available;
76 /* Nonzero if the section map MUST be updated before use. */
77 int section_map_dirty;
79 /* Nonzero if section map updates should be inhibited if possible. */
83 /* Per-program-space data key. */
84 static const struct program_space_data *objfiles_pspace_data;
87 objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
89 struct objfile_pspace_info *info = (struct objfile_pspace_info *) arg;
91 xfree (info->sections);
95 /* Get the current svr4 data. If none is found yet, add it now. This
96 function always returns a valid object. */
98 static struct objfile_pspace_info *
99 get_objfile_pspace_data (struct program_space *pspace)
101 struct objfile_pspace_info *info;
103 info = ((struct objfile_pspace_info *)
104 program_space_data (pspace, objfiles_pspace_data));
107 info = XCNEW (struct objfile_pspace_info);
108 set_program_space_data (pspace, objfiles_pspace_data, info);
116 /* Per-BFD data key. */
118 static const struct bfd_data *objfiles_bfd_data;
120 objfile_per_bfd_storage::~objfile_per_bfd_storage ()
122 if (demangled_names_hash)
123 htab_delete (demangled_names_hash);
126 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
127 NULL, and it already has a per-BFD storage object, use that.
128 Otherwise, allocate a new per-BFD storage object. Note that it is
129 not safe to call this multiple times for a given OBJFILE -- it can
130 only be called when allocating or re-initializing OBJFILE. */
132 static struct objfile_per_bfd_storage *
133 get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
135 struct objfile_per_bfd_storage *storage = NULL;
138 storage = ((struct objfile_per_bfd_storage *)
139 bfd_data (abfd, objfiles_bfd_data));
143 storage = new objfile_per_bfd_storage;
144 /* If the object requires gdb to do relocations, we simply fall
145 back to not sharing data across users. These cases are rare
146 enough that this seems reasonable. */
147 if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
148 set_bfd_data (abfd, objfiles_bfd_data, storage);
150 /* Look up the gdbarch associated with the BFD. */
152 storage->gdbarch = gdbarch_from_bfd (abfd);
158 /* A deleter for objfile_per_bfd_storage that can be passed as a
159 cleanup function to the BFD registry. */
162 objfile_bfd_data_free (struct bfd *unused, void *d)
164 delete (struct objfile_per_bfd_storage *) d;
167 /* See objfiles.h. */
170 set_objfile_per_bfd (struct objfile *objfile)
172 objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd);
175 /* Set the objfile's per-BFD notion of the "main" name and
179 set_objfile_main_name (struct objfile *objfile,
180 const char *name, enum language lang)
182 if (objfile->per_bfd->name_of_main == NULL
183 || strcmp (objfile->per_bfd->name_of_main, name) != 0)
184 objfile->per_bfd->name_of_main
185 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack, name,
187 objfile->per_bfd->language_of_main = lang;
190 /* Helper structure to map blocks to static link properties in hash tables. */
192 struct static_link_htab_entry
194 const struct block *block;
195 const struct dynamic_prop *static_link;
198 /* Return a hash code for struct static_link_htab_entry *P. */
201 static_link_htab_entry_hash (const void *p)
203 const struct static_link_htab_entry *e
204 = (const struct static_link_htab_entry *) p;
206 return htab_hash_pointer (e->block);
209 /* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
210 mappings for the same block. */
213 static_link_htab_entry_eq (const void *p1, const void *p2)
215 const struct static_link_htab_entry *e1
216 = (const struct static_link_htab_entry *) p1;
217 const struct static_link_htab_entry *e2
218 = (const struct static_link_htab_entry *) p2;
220 return e1->block == e2->block;
223 /* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
224 Must not be called more than once for each BLOCK. */
227 objfile_register_static_link (struct objfile *objfile,
228 const struct block *block,
229 const struct dynamic_prop *static_link)
232 struct static_link_htab_entry lookup_entry;
233 struct static_link_htab_entry *entry;
235 if (objfile->static_links == NULL)
236 objfile->static_links = htab_create_alloc
237 (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL,
240 /* Create a slot for the mapping, make sure it's the first mapping for this
241 block and then create the mapping itself. */
242 lookup_entry.block = block;
243 slot = htab_find_slot (objfile->static_links, &lookup_entry, INSERT);
244 gdb_assert (*slot == NULL);
246 entry = XOBNEW (&objfile->objfile_obstack, static_link_htab_entry);
247 entry->block = block;
248 entry->static_link = static_link;
249 *slot = (void *) entry;
252 /* Look for a static link for BLOCK, which is part of OBJFILE. Return NULL if
255 const struct dynamic_prop *
256 objfile_lookup_static_link (struct objfile *objfile,
257 const struct block *block)
259 struct static_link_htab_entry *entry;
260 struct static_link_htab_entry lookup_entry;
262 if (objfile->static_links == NULL)
264 lookup_entry.block = block;
266 = (struct static_link_htab_entry *) htab_find (objfile->static_links,
271 gdb_assert (entry->block == block);
272 return entry->static_link;
277 /* Called via bfd_map_over_sections to build up the section table that
278 the objfile references. The objfile contains pointers to the start
279 of the table (objfile->sections) and to the first location after
280 the end of the table (objfile->sections_end). */
283 add_to_objfile_sections_full (struct bfd *abfd, struct bfd_section *asect,
284 struct objfile *objfile, int force)
286 struct obj_section *section;
292 aflag = bfd_get_section_flags (abfd, asect);
293 if (!(aflag & SEC_ALLOC))
297 section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
298 section->objfile = objfile;
299 section->the_bfd_section = asect;
300 section->ovly_mapped = 0;
304 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
307 add_to_objfile_sections_full (abfd, asect, (struct objfile *) objfilep, 0);
310 /* Builds a section table for OBJFILE.
312 Note that the OFFSET and OVLY_MAPPED in each table entry are
313 initialized to zero. */
316 build_objfile_section_table (struct objfile *objfile)
318 int count = gdb_bfd_count_sections (objfile->obfd);
320 objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
323 objfile->sections_end = (objfile->sections + count);
324 bfd_map_over_sections (objfile->obfd,
325 add_to_objfile_sections, (void *) objfile);
327 /* See gdb_bfd_section_index. */
328 add_to_objfile_sections_full (objfile->obfd, bfd_com_section_ptr, objfile, 1);
329 add_to_objfile_sections_full (objfile->obfd, bfd_und_section_ptr, objfile, 1);
330 add_to_objfile_sections_full (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
331 add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
334 /* Given a pointer to an initialized bfd (ABFD) and some flag bits,
335 initialize the new objfile as best we can and link it into the list
336 of all known objfiles.
338 NAME should contain original non-canonicalized filename or other
339 identifier as entered by user. If there is no better source use
340 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
341 NAME content is copied into returned objfile.
343 The FLAGS word contains various bits (OBJF_*) that can be taken as
344 requests for specific operations. Other bits like OBJF_SHARED are
345 simply copied through to the new objfile flags member. */
347 objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
349 pspace (current_program_space),
350 partial_symtabs (new psymtab_storage ()),
353 const char *expanded_name;
355 /* We could use obstack_specify_allocation here instead, but
356 gdb_obstack.h specifies the alloc/dealloc functions. */
357 obstack_init (&objfile_obstack);
359 objfile_alloc_data (this);
361 gdb::unique_xmalloc_ptr<char> name_holder;
364 gdb_assert (abfd == NULL);
365 gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
366 expanded_name = "<<anonymous objfile>>";
368 else if ((flags & OBJF_NOT_FILENAME) != 0
369 || is_target_filename (name))
370 expanded_name = name;
373 name_holder = gdb_abspath (name);
374 expanded_name = name_holder.get ();
377 = (char *) obstack_copy0 (&objfile_obstack,
379 strlen (expanded_name));
381 /* Update the per-objfile information that comes from the bfd, ensuring
382 that any data that is reference is saved in the per-objfile data
388 mtime = bfd_get_mtime (abfd);
390 /* Build section table. */
391 build_objfile_section_table (this);
394 per_bfd = get_objfile_bfd_data (this, abfd);
396 /* Add this file onto the tail of the linked list of other such files. */
398 if (object_files == NULL)
402 struct objfile *last_one;
404 for (last_one = object_files;
406 last_one = last_one->next);
407 last_one->next = this;
410 /* Rebuild section map next time we need it. */
411 get_objfile_pspace_data (pspace)->new_objfiles_available = 1;
414 /* Retrieve the gdbarch associated with OBJFILE. */
417 get_objfile_arch (const struct objfile *objfile)
419 return objfile->per_bfd->gdbarch;
422 /* If there is a valid and known entry point, function fills *ENTRY_P with it
423 and returns non-zero; otherwise it returns zero. */
426 entry_point_address_query (CORE_ADDR *entry_p)
428 if (symfile_objfile == NULL || !symfile_objfile->per_bfd->ei.entry_point_p)
431 *entry_p = (symfile_objfile->per_bfd->ei.entry_point
432 + ANOFFSET (symfile_objfile->section_offsets,
433 symfile_objfile->per_bfd->ei.the_bfd_section_index));
438 /* Get current entry point address. Call error if it is not known. */
441 entry_point_address (void)
445 if (!entry_point_address_query (&retval))
446 error (_("Entry point address is not known."));
451 /* Iterator on PARENT and every separate debug objfile of PARENT.
452 The usage pattern is:
453 for (objfile = parent;
455 objfile = objfile_separate_debug_iterate (parent, objfile))
460 objfile_separate_debug_iterate (const struct objfile *parent,
461 const struct objfile *objfile)
465 /* If any, return the first child. */
466 res = objfile->separate_debug_objfile;
470 /* Common case where there is no separate debug objfile. */
471 if (objfile == parent)
474 /* Return the brother if any. Note that we don't iterate on brothers of
476 res = objfile->separate_debug_objfile_link;
480 for (res = objfile->separate_debug_objfile_backlink;
482 res = res->separate_debug_objfile_backlink)
484 gdb_assert (res != NULL);
485 if (res->separate_debug_objfile_link)
486 return res->separate_debug_objfile_link;
491 /* Put one object file before a specified on in the global list.
492 This can be used to make sure an object file is destroyed before
493 another when using objfiles_safe to free all objfiles. */
495 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
497 struct objfile **objp;
499 unlink_objfile (objfile);
501 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
503 if (*objp == before_this)
505 objfile->next = *objp;
511 internal_error (__FILE__, __LINE__,
512 _("put_objfile_before: before objfile not in list"));
515 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
518 It is not a bug, or error, to call this function if OBJFILE is not known
519 to be in the current list. This is done in the case of mapped objfiles,
520 for example, just to ensure that the mapped objfile doesn't appear twice
521 in the list. Since the list is threaded, linking in a mapped objfile
522 twice would create a circular list.
524 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
525 unlinking it, just to ensure that we have completely severed any linkages
526 between the OBJFILE and the list. */
529 unlink_objfile (struct objfile *objfile)
531 struct objfile **objpp;
533 for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
535 if (*objpp == objfile)
537 *objpp = (*objpp)->next;
538 objfile->next = NULL;
543 internal_error (__FILE__, __LINE__,
544 _("unlink_objfile: objfile already unlinked"));
547 /* Add OBJFILE as a separate debug objfile of PARENT. */
550 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
552 gdb_assert (objfile && parent);
554 /* Must not be already in a list. */
555 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
556 gdb_assert (objfile->separate_debug_objfile_link == NULL);
557 gdb_assert (objfile->separate_debug_objfile == NULL);
558 gdb_assert (parent->separate_debug_objfile_backlink == NULL);
559 gdb_assert (parent->separate_debug_objfile_link == NULL);
561 objfile->separate_debug_objfile_backlink = parent;
562 objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
563 parent->separate_debug_objfile = objfile;
565 /* Put the separate debug object before the normal one, this is so that
566 usage of objfiles_safe will stay safe. */
567 put_objfile_before (objfile, parent);
570 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
574 free_objfile_separate_debug (struct objfile *objfile)
576 struct objfile *child;
578 for (child = objfile->separate_debug_objfile; child;)
580 struct objfile *next_child = child->separate_debug_objfile_link;
586 /* Destroy an objfile and all the symtabs and psymtabs under it. */
590 /* First notify observers that this objfile is about to be freed. */
591 gdb::observers::free_objfile.notify (this);
593 /* Free all separate debug objfiles. */
594 free_objfile_separate_debug (this);
596 if (separate_debug_objfile_backlink)
598 /* We freed the separate debug file, make sure the base objfile
599 doesn't reference it. */
600 struct objfile *child;
602 child = separate_debug_objfile_backlink->separate_debug_objfile;
606 /* THIS is the first child. */
607 separate_debug_objfile_backlink->separate_debug_objfile =
608 separate_debug_objfile_link;
612 /* Find THIS in the list. */
615 if (child->separate_debug_objfile_link == this)
617 child->separate_debug_objfile_link =
618 separate_debug_objfile_link;
621 child = child->separate_debug_objfile_link;
627 /* Remove any references to this objfile in the global value
629 preserve_values (this);
631 /* It still may reference data modules have associated with the objfile and
632 the symbol file data. */
633 forget_cached_source_info_for_objfile (this);
635 breakpoint_free_objfile (this);
636 btrace_free_objfile (this);
638 /* First do any symbol file specific actions required when we are
639 finished with a particular symbol file. Note that if the objfile
640 is using reusable symbol information (via mmalloc) then each of
641 these routines is responsible for doing the correct thing, either
642 freeing things which are valid only during this particular gdb
643 execution, or leaving them to be reused during the next one. */
646 (*sf->sym_finish) (this);
648 /* Discard any data modules have associated with the objfile. The function
649 still may reference obfd. */
650 objfile_free_data (this);
653 gdb_bfd_unref (obfd);
657 /* Remove it from the chain of all objfiles. */
659 unlink_objfile (this);
661 if (this == symfile_objfile)
662 symfile_objfile = NULL;
664 /* Before the symbol table code was redone to make it easier to
665 selectively load and remove information particular to a specific
666 linkage unit, gdb used to do these things whenever the monolithic
667 symbol table was blown away. How much still needs to be done
668 is unknown, but we play it safe for now and keep each action until
669 it is shown to be no longer needed. */
671 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
672 for example), so we need to call this here. */
673 clear_pc_function_cache ();
675 /* Clear globals which might have pointed into a removed objfile.
676 FIXME: It's not clear which of these are supposed to persist
677 between expressions and which ought to be reset each time. */
678 expression_context_block = NULL;
679 innermost_block.reset ();
681 /* Check to see if the current_source_symtab belongs to this objfile,
682 and if so, call clear_current_source_symtab_and_line. */
685 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
687 if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == this)
688 clear_current_source_symtab_and_line ();
691 /* Free the obstacks for non-reusable objfiles. */
692 obstack_free (&objfile_obstack, 0);
694 /* Rebuild section map next time we need it. */
695 get_objfile_pspace_data (pspace)->section_map_dirty = 1;
697 /* Free the map for static links. There's no need to free static link
698 themselves since they were allocated on the objstack. */
699 if (static_links != NULL)
700 htab_delete (static_links);
703 /* Free all the object files at once and clean up their users. */
706 free_all_objfiles (void)
710 /* Any objfile referencewould become stale. */
711 for (so = master_so_list (); so; so = so->next)
712 gdb_assert (so->objfile == NULL);
714 for (objfile *objfile : current_program_space->objfiles_safe ())
716 clear_symtab_users (0);
719 /* A helper function for objfile_relocate1 that relocates a single
723 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
724 struct section_offsets *delta)
726 fixup_symbol_section (sym, objfile);
728 /* The RS6000 code from which this was taken skipped
729 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
730 But I'm leaving out that test, on the theory that
731 they can't possibly pass the tests below. */
732 if ((SYMBOL_CLASS (sym) == LOC_LABEL
733 || SYMBOL_CLASS (sym) == LOC_STATIC)
734 && SYMBOL_SECTION (sym) >= 0)
736 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
740 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
741 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
742 Return non-zero iff any change happened. */
745 objfile_relocate1 (struct objfile *objfile,
746 const struct section_offsets *new_offsets)
748 struct section_offsets *delta =
749 ((struct section_offsets *)
750 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
752 int something_changed = 0;
754 for (int i = 0; i < objfile->num_sections; ++i)
757 ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
758 if (ANOFFSET (delta, i) != 0)
759 something_changed = 1;
761 if (!something_changed)
764 /* OK, get all the symtabs. */
766 for (compunit_symtab *cust : objfile->compunits ())
768 for (symtab *s : compunit_filetabs (cust))
772 /* First the line table. */
773 l = SYMTAB_LINETABLE (s);
776 for (int i = 0; i < l->nitems; ++i)
777 l->item[i].pc += ANOFFSET (delta,
778 COMPUNIT_BLOCK_LINE_SECTION
784 for (compunit_symtab *cust : objfile->compunits ())
786 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
787 int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust);
789 if (BLOCKVECTOR_MAP (bv))
790 addrmap_relocate (BLOCKVECTOR_MAP (bv),
791 ANOFFSET (delta, block_line_section));
793 for (int i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
797 struct mdict_iterator miter;
799 b = BLOCKVECTOR_BLOCK (bv, i);
800 BLOCK_START (b) += ANOFFSET (delta, block_line_section);
801 BLOCK_END (b) += ANOFFSET (delta, block_line_section);
803 if (BLOCK_RANGES (b) != nullptr)
804 for (int j = 0; j < BLOCK_NRANGES (b); j++)
806 BLOCK_RANGE_START (b, j)
807 += ANOFFSET (delta, block_line_section);
808 BLOCK_RANGE_END (b, j) += ANOFFSET (delta,
812 /* We only want to iterate over the local symbols, not any
813 symbols in included symtabs. */
814 ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
816 relocate_one_symbol (sym, objfile, delta);
822 /* This stores relocated addresses and so must be cleared. This
823 will cause it to be recreated on demand. */
824 objfile->psymbol_map.clear ();
826 /* Relocate isolated symbols. */
830 for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
831 relocate_one_symbol (iter, objfile, delta);
837 for (i = 0; i < objfile->num_sections; ++i)
838 (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
841 /* Rebuild section map next time we need it. */
842 get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
844 /* Update the table in exec_ops, used to read memory. */
845 struct obj_section *s;
846 ALL_OBJFILE_OSECTIONS (objfile, s)
848 int idx = s - objfile->sections;
850 exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
851 obj_section_addr (s));
858 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
859 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
861 The number and ordering of sections does differ between the two objfiles.
862 Only their names match. Also the file offsets will differ (objfile being
863 possibly prelinked but separate_debug_objfile is probably not prelinked) but
864 the in-memory absolute address as specified by NEW_OFFSETS must match both
868 objfile_relocate (struct objfile *objfile,
869 const struct section_offsets *new_offsets)
871 struct objfile *debug_objfile;
874 changed |= objfile_relocate1 (objfile, new_offsets);
876 for (debug_objfile = objfile->separate_debug_objfile;
878 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
880 section_addr_info objfile_addrs
881 = build_section_addr_info_from_objfile (objfile);
883 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
884 relative ones must be already created according to debug_objfile. */
886 addr_info_make_relative (&objfile_addrs, debug_objfile->obfd);
888 gdb_assert (debug_objfile->num_sections
889 == gdb_bfd_count_sections (debug_objfile->obfd));
890 std::vector<struct section_offsets>
891 new_debug_offsets (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
892 relative_addr_info_to_section_offsets (new_debug_offsets.data (),
893 debug_objfile->num_sections,
896 changed |= objfile_relocate1 (debug_objfile, new_debug_offsets.data ());
899 /* Relocate breakpoints as necessary, after things are relocated. */
901 breakpoint_re_set ();
904 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
906 Return non-zero iff any change happened. */
909 objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
911 struct section_offsets *new_offsets =
912 ((struct section_offsets *)
913 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
916 for (i = 0; i < objfile->num_sections; ++i)
917 new_offsets->offsets[i] = slide;
919 return objfile_relocate1 (objfile, new_offsets);
922 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
923 SEPARATE_DEBUG_OBJFILEs. */
926 objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
928 struct objfile *debug_objfile;
931 changed |= objfile_rebase1 (objfile, slide);
933 for (debug_objfile = objfile->separate_debug_objfile;
935 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
936 changed |= objfile_rebase1 (debug_objfile, slide);
938 /* Relocate breakpoints as necessary, after things are relocated. */
940 breakpoint_re_set ();
943 /* Return non-zero if OBJFILE has partial symbols. */
946 objfile_has_partial_symbols (struct objfile *objfile)
951 /* If we have not read psymbols, but we have a function capable of reading
952 them, then that is an indication that they are in fact available. Without
953 this function the symbols may have been already read in but they also may
954 not be present in this objfile. */
955 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
956 && objfile->sf->sym_read_psymbols != NULL)
959 return objfile->sf->qf->has_symbols (objfile);
962 /* Return non-zero if OBJFILE has full symbols. */
965 objfile_has_full_symbols (struct objfile *objfile)
967 return objfile->compunit_symtabs != NULL;
970 /* Return non-zero if OBJFILE has full or partial symbols, either directly
971 or through a separate debug file. */
974 objfile_has_symbols (struct objfile *objfile)
978 for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
979 if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
985 /* Many places in gdb want to test just to see if we have any partial
986 symbols available. This function returns zero if none are currently
987 available, nonzero otherwise. */
990 have_partial_symbols (void)
992 for (objfile *ofp : current_program_space->objfiles ())
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 for (objfile *ofp : current_program_space->objfiles ())
1009 if (objfile_has_full_symbols (ofp))
1016 /* This operations deletes all objfile entries that represent solibs that
1017 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1021 objfile_purge_solibs (void)
1023 for (objfile *objf : current_program_space->objfiles_safe ())
1025 /* We assume that the solib package has been purged already, or will
1028 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
1034 /* Many places in gdb want to test just to see if we have any minimal
1035 symbols available. This function returns zero if none are currently
1036 available, nonzero otherwise. */
1039 have_minimal_symbols (void)
1041 for (objfile *ofp : current_program_space->objfiles ())
1043 if (ofp->per_bfd->minimal_symbol_count > 0)
1051 /* Qsort comparison function. */
1054 qsort_cmp (const void *a, const void *b)
1056 const struct obj_section *sect1 = *(const struct obj_section **) a;
1057 const struct obj_section *sect2 = *(const struct obj_section **) b;
1058 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1059 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1061 if (sect1_addr < sect2_addr)
1063 else if (sect1_addr > sect2_addr)
1067 /* Sections are at the same address. This could happen if
1068 A) we have an objfile and a separate debuginfo.
1069 B) we are confused, and have added sections without proper relocation,
1070 or something like that. */
1072 const struct objfile *const objfile1 = sect1->objfile;
1073 const struct objfile *const objfile2 = sect2->objfile;
1075 if (objfile1->separate_debug_objfile == objfile2
1076 || objfile2->separate_debug_objfile == objfile1)
1078 /* Case A. The ordering doesn't matter: separate debuginfo files
1079 will be filtered out later. */
1084 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1085 triage. This section could be slow (since we iterate over all
1086 objfiles in each call to qsort_cmp), but this shouldn't happen
1087 very often (GDB is already in a confused state; one hopes this
1088 doesn't happen at all). If you discover that significant time is
1089 spent in the loops below, do 'set complaints 100' and examine the
1090 resulting complaints. */
1092 if (objfile1 == objfile2)
1094 /* Both sections came from the same objfile. We are really confused.
1095 Sort on sequence order of sections within the objfile. */
1097 const struct obj_section *osect;
1099 ALL_OBJFILE_OSECTIONS (objfile1, osect)
1102 else if (osect == sect2)
1105 /* We should have found one of the sections before getting here. */
1106 gdb_assert_not_reached ("section not found");
1110 /* Sort on sequence number of the objfile in the chain. */
1112 for (objfile *objfile : current_program_space->objfiles ())
1113 if (objfile == objfile1)
1115 else if (objfile == objfile2)
1118 /* We should have found one of the objfiles before getting here. */
1119 gdb_assert_not_reached ("objfile not found");
1124 gdb_assert_not_reached ("unexpected code path");
1128 /* Select "better" obj_section to keep. We prefer the one that came from
1129 the real object, rather than the one from separate debuginfo.
1130 Most of the time the two sections are exactly identical, but with
1131 prelinking the .rel.dyn section in the real object may have different
1134 static struct obj_section *
1135 preferred_obj_section (struct obj_section *a, struct obj_section *b)
1137 gdb_assert (obj_section_addr (a) == obj_section_addr (b));
1138 gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
1139 || (b->objfile->separate_debug_objfile == a->objfile));
1140 gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
1141 || (b->objfile->separate_debug_objfile_backlink == a->objfile));
1143 if (a->objfile->separate_debug_objfile != NULL)
1148 /* Return 1 if SECTION should be inserted into the section map.
1149 We want to insert only non-overlay and non-TLS section. */
1152 insert_section_p (const struct bfd *abfd,
1153 const struct bfd_section *section)
1155 const bfd_vma lma = bfd_section_lma (abfd, section);
1157 if (overlay_debugging && lma != 0 && lma != bfd_section_vma (abfd, section)
1158 && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1159 /* This is an overlay section. IN_MEMORY check is needed to avoid
1160 discarding sections from the "system supplied DSO" (aka vdso)
1161 on some Linux systems (e.g. Fedora 11). */
1163 if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1164 /* This is a TLS section. */
1170 /* Filter out overlapping sections where one section came from the real
1171 objfile, and the other from a separate debuginfo file.
1172 Return the size of table after redundant sections have been eliminated. */
1175 filter_debuginfo_sections (struct obj_section **map, int map_size)
1179 for (i = 0, j = 0; i < map_size - 1; i++)
1181 struct obj_section *const sect1 = map[i];
1182 struct obj_section *const sect2 = map[i + 1];
1183 const struct objfile *const objfile1 = sect1->objfile;
1184 const struct objfile *const objfile2 = sect2->objfile;
1185 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1186 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1188 if (sect1_addr == sect2_addr
1189 && (objfile1->separate_debug_objfile == objfile2
1190 || objfile2->separate_debug_objfile == objfile1))
1192 map[j++] = preferred_obj_section (sect1, sect2);
1201 gdb_assert (i == map_size - 1);
1205 /* The map should not have shrunk to less than half the original size. */
1206 gdb_assert (map_size / 2 <= j);
1211 /* Filter out overlapping sections, issuing a warning if any are found.
1212 Overlapping sections could really be overlay sections which we didn't
1213 classify as such in insert_section_p, or we could be dealing with a
1217 filter_overlapping_sections (struct obj_section **map, int map_size)
1221 for (i = 0, j = 0; i < map_size - 1; )
1226 for (k = i + 1; k < map_size; k++)
1228 struct obj_section *const sect1 = map[i];
1229 struct obj_section *const sect2 = map[k];
1230 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1231 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1232 const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1234 gdb_assert (sect1_addr <= sect2_addr);
1236 if (sect1_endaddr <= sect2_addr)
1240 /* We have an overlap. Report it. */
1242 struct objfile *const objf1 = sect1->objfile;
1243 struct objfile *const objf2 = sect2->objfile;
1245 const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1246 const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1248 const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1250 struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1252 complaint (_("unexpected overlap between:\n"
1253 " (A) section `%s' from `%s' [%s, %s)\n"
1254 " (B) section `%s' from `%s' [%s, %s).\n"
1255 "Will ignore section B"),
1256 bfd_section_name (abfd1, bfds1), objfile_name (objf1),
1257 paddress (gdbarch, sect1_addr),
1258 paddress (gdbarch, sect1_endaddr),
1259 bfd_section_name (abfd2, bfds2), objfile_name (objf2),
1260 paddress (gdbarch, sect2_addr),
1261 paddress (gdbarch, sect2_endaddr));
1269 gdb_assert (i == map_size - 1);
1277 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1278 TLS, overlay and overlapping sections. */
1281 update_section_map (struct program_space *pspace,
1282 struct obj_section ***pmap, int *pmap_size)
1284 struct objfile_pspace_info *pspace_info;
1285 int alloc_size, map_size, i;
1286 struct obj_section *s, **map;
1288 pspace_info = get_objfile_pspace_data (pspace);
1289 gdb_assert (pspace_info->section_map_dirty != 0
1290 || pspace_info->new_objfiles_available != 0);
1296 for (objfile *objfile : pspace->objfiles ())
1297 ALL_OBJFILE_OSECTIONS (objfile, s)
1298 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1301 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1302 if (alloc_size == 0)
1309 map = XNEWVEC (struct obj_section *, alloc_size);
1312 for (objfile *objfile : pspace->objfiles ())
1313 ALL_OBJFILE_OSECTIONS (objfile, s)
1314 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1317 qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1318 map_size = filter_debuginfo_sections(map, alloc_size);
1319 map_size = filter_overlapping_sections(map, map_size);
1321 if (map_size < alloc_size)
1322 /* Some sections were eliminated. Trim excess space. */
1323 map = XRESIZEVEC (struct obj_section *, map, map_size);
1325 gdb_assert (alloc_size == map_size);
1328 *pmap_size = map_size;
1331 /* Bsearch comparison function. */
1334 bsearch_cmp (const void *key, const void *elt)
1336 const CORE_ADDR pc = *(CORE_ADDR *) key;
1337 const struct obj_section *section = *(const struct obj_section **) elt;
1339 if (pc < obj_section_addr (section))
1341 if (pc < obj_section_endaddr (section))
1346 /* Returns a section whose range includes PC or NULL if none found. */
1348 struct obj_section *
1349 find_pc_section (CORE_ADDR pc)
1351 struct objfile_pspace_info *pspace_info;
1352 struct obj_section *s, **sp;
1354 /* Check for mapped overlay section first. */
1355 s = find_pc_mapped_section (pc);
1359 pspace_info = get_objfile_pspace_data (current_program_space);
1360 if (pspace_info->section_map_dirty
1361 || (pspace_info->new_objfiles_available
1362 && !pspace_info->inhibit_updates))
1364 update_section_map (current_program_space,
1365 &pspace_info->sections,
1366 &pspace_info->num_sections);
1368 /* Don't need updates to section map until objfiles are added,
1369 removed or relocated. */
1370 pspace_info->new_objfiles_available = 0;
1371 pspace_info->section_map_dirty = 0;
1374 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1375 bsearch be non-NULL. */
1376 if (pspace_info->sections == NULL)
1378 gdb_assert (pspace_info->num_sections == 0);
1382 sp = (struct obj_section **) bsearch (&pc,
1383 pspace_info->sections,
1384 pspace_info->num_sections,
1385 sizeof (*pspace_info->sections),
1393 /* Return non-zero if PC is in a section called NAME. */
1396 pc_in_section (CORE_ADDR pc, const char *name)
1398 struct obj_section *s;
1401 s = find_pc_section (pc);
1404 && s->the_bfd_section->name != NULL
1405 && strcmp (s->the_bfd_section->name, name) == 0);
1410 /* Set section_map_dirty so section map will be rebuilt next time it
1411 is used. Called by reread_symbols. */
1414 objfiles_changed (void)
1416 /* Rebuild section map next time we need it. */
1417 get_objfile_pspace_data (current_program_space)->section_map_dirty = 1;
1420 /* See comments in objfiles.h. */
1422 scoped_restore_tmpl<int>
1423 inhibit_section_map_updates (struct program_space *pspace)
1425 return scoped_restore_tmpl<int>
1426 (&get_objfile_pspace_data (pspace)->inhibit_updates, 1);
1429 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1433 is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile)
1435 struct obj_section *osect;
1437 if (objfile == NULL)
1440 ALL_OBJFILE_OSECTIONS (objfile, osect)
1442 if (section_is_overlay (osect) && !section_is_mapped (osect))
1445 if (obj_section_addr (osect) <= addr
1446 && addr < obj_section_endaddr (osect))
1453 shared_objfile_contains_address_p (struct program_space *pspace,
1456 for (objfile *objfile : pspace->objfiles ())
1458 if ((objfile->flags & OBJF_SHARED) != 0
1459 && is_addr_in_objfile (address, objfile))
1466 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1467 gdbarch method. It is equivalent to use the objfiles iterable,
1468 searching the objfiles in the order they are stored internally,
1469 ignoring CURRENT_OBJFILE.
1471 On most platorms, it should be close enough to doing the best
1472 we can without some knowledge specific to the architecture. */
1475 default_iterate_over_objfiles_in_search_order
1476 (struct gdbarch *gdbarch,
1477 iterate_over_objfiles_in_search_order_cb_ftype *cb,
1478 void *cb_data, struct objfile *current_objfile)
1482 for (objfile *objfile : current_program_space->objfiles ())
1484 stop = cb (objfile, cb_data);
1490 /* See objfiles.h. */
1493 objfile_name (const struct objfile *objfile)
1495 if (objfile->obfd != NULL)
1496 return bfd_get_filename (objfile->obfd);
1498 return objfile->original_name;
1501 /* See objfiles.h. */
1504 objfile_filename (const struct objfile *objfile)
1506 if (objfile->obfd != NULL)
1507 return bfd_get_filename (objfile->obfd);
1512 /* See objfiles.h. */
1515 objfile_debug_name (const struct objfile *objfile)
1517 return lbasename (objfile->original_name);
1520 /* See objfiles.h. */
1523 objfile_flavour_name (struct objfile *objfile)
1525 if (objfile->obfd != NULL)
1526 return bfd_flavour_name (bfd_get_flavour (objfile->obfd));
1531 _initialize_objfiles (void)
1533 objfiles_pspace_data
1534 = register_program_space_data_with_cleanup (NULL,
1535 objfiles_pspace_data_cleanup);
1537 objfiles_bfd_data = register_bfd_data_with_cleanup (NULL,
1538 objfile_bfd_data_free);