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 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
121 NULL, and it already has a per-BFD storage object, use that.
122 Otherwise, allocate a new per-BFD storage object. If ABFD is not
123 NULL, the object is allocated on the BFD; otherwise it is allocated
124 on OBJFILE's obstack. Note that it is not safe to call this
125 multiple times for a given OBJFILE -- it can only be called when
126 allocating or re-initializing OBJFILE. */
128 static struct objfile_per_bfd_storage
*
129 get_objfile_bfd_data (struct objfile
*objfile
, struct bfd
*abfd
)
131 struct objfile_per_bfd_storage
*storage
= NULL
;
134 storage
= ((struct objfile_per_bfd_storage
*)
135 bfd_data (abfd
, objfiles_bfd_data
));
139 /* If the object requires gdb to do relocations, we simply fall
140 back to not sharing data across users. These cases are rare
141 enough that this seems reasonable. */
142 if (abfd
!= NULL
&& !gdb_bfd_requires_relocations (abfd
))
145 = ((struct objfile_per_bfd_storage
*)
146 bfd_alloc (abfd
, sizeof (struct objfile_per_bfd_storage
)));
147 /* objfile_per_bfd_storage is not trivially constructible, must
148 call the ctor manually. */
149 storage
= new (storage
) objfile_per_bfd_storage ();
150 set_bfd_data (abfd
, objfiles_bfd_data
, storage
);
154 = obstack_new
<objfile_per_bfd_storage
> (&objfile
->objfile_obstack
);
156 /* Look up the gdbarch associated with the BFD. */
158 storage
->gdbarch
= gdbarch_from_bfd (abfd
);
160 storage
->filename_cache
= bcache_xmalloc (NULL
, NULL
);
161 storage
->macro_cache
= bcache_xmalloc (NULL
, NULL
);
162 storage
->language_of_main
= language_unknown
;
171 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage
*storage
)
173 bcache_xfree (storage
->filename_cache
);
174 bcache_xfree (storage
->macro_cache
);
175 if (storage
->demangled_names_hash
)
176 htab_delete (storage
->demangled_names_hash
);
177 storage
->~objfile_per_bfd_storage ();
180 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
181 cleanup function to the BFD registry. */
184 objfile_bfd_data_free (struct bfd
*unused
, void *d
)
186 free_objfile_per_bfd_storage ((struct objfile_per_bfd_storage
*) d
);
189 /* See objfiles.h. */
192 set_objfile_per_bfd (struct objfile
*objfile
)
194 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, objfile
->obfd
);
197 /* Set the objfile's per-BFD notion of the "main" name and
201 set_objfile_main_name (struct objfile
*objfile
,
202 const char *name
, enum language lang
)
204 if (objfile
->per_bfd
->name_of_main
== NULL
205 || strcmp (objfile
->per_bfd
->name_of_main
, name
) != 0)
206 objfile
->per_bfd
->name_of_main
207 = (const char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
, name
,
209 objfile
->per_bfd
->language_of_main
= lang
;
212 /* Helper structure to map blocks to static link properties in hash tables. */
214 struct static_link_htab_entry
216 const struct block
*block
;
217 const struct dynamic_prop
*static_link
;
220 /* Return a hash code for struct static_link_htab_entry *P. */
223 static_link_htab_entry_hash (const void *p
)
225 const struct static_link_htab_entry
*e
226 = (const struct static_link_htab_entry
*) p
;
228 return htab_hash_pointer (e
->block
);
231 /* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
232 mappings for the same block. */
235 static_link_htab_entry_eq (const void *p1
, const void *p2
)
237 const struct static_link_htab_entry
*e1
238 = (const struct static_link_htab_entry
*) p1
;
239 const struct static_link_htab_entry
*e2
240 = (const struct static_link_htab_entry
*) p2
;
242 return e1
->block
== e2
->block
;
245 /* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
246 Must not be called more than once for each BLOCK. */
249 objfile_register_static_link (struct objfile
*objfile
,
250 const struct block
*block
,
251 const struct dynamic_prop
*static_link
)
254 struct static_link_htab_entry lookup_entry
;
255 struct static_link_htab_entry
*entry
;
257 if (objfile
->static_links
== NULL
)
258 objfile
->static_links
= htab_create_alloc
259 (1, &static_link_htab_entry_hash
, static_link_htab_entry_eq
, NULL
,
262 /* Create a slot for the mapping, make sure it's the first mapping for this
263 block and then create the mapping itself. */
264 lookup_entry
.block
= block
;
265 slot
= htab_find_slot (objfile
->static_links
, &lookup_entry
, INSERT
);
266 gdb_assert (*slot
== NULL
);
268 entry
= XOBNEW (&objfile
->objfile_obstack
, static_link_htab_entry
);
269 entry
->block
= block
;
270 entry
->static_link
= static_link
;
271 *slot
= (void *) entry
;
274 /* Look for a static link for BLOCK, which is part of OBJFILE. Return NULL if
277 const struct dynamic_prop
*
278 objfile_lookup_static_link (struct objfile
*objfile
,
279 const struct block
*block
)
281 struct static_link_htab_entry
*entry
;
282 struct static_link_htab_entry lookup_entry
;
284 if (objfile
->static_links
== NULL
)
286 lookup_entry
.block
= block
;
288 = (struct static_link_htab_entry
*) htab_find (objfile
->static_links
,
293 gdb_assert (entry
->block
== block
);
294 return entry
->static_link
;
299 /* Called via bfd_map_over_sections to build up the section table that
300 the objfile references. The objfile contains pointers to the start
301 of the table (objfile->sections) and to the first location after
302 the end of the table (objfile->sections_end). */
305 add_to_objfile_sections_full (struct bfd
*abfd
, struct bfd_section
*asect
,
306 struct objfile
*objfile
, int force
)
308 struct obj_section
*section
;
314 aflag
= bfd_get_section_flags (abfd
, asect
);
315 if (!(aflag
& SEC_ALLOC
))
319 section
= &objfile
->sections
[gdb_bfd_section_index (abfd
, asect
)];
320 section
->objfile
= objfile
;
321 section
->the_bfd_section
= asect
;
322 section
->ovly_mapped
= 0;
326 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
329 add_to_objfile_sections_full (abfd
, asect
, (struct objfile
*) objfilep
, 0);
332 /* Builds a section table for OBJFILE.
334 Note that the OFFSET and OVLY_MAPPED in each table entry are
335 initialized to zero. */
338 build_objfile_section_table (struct objfile
*objfile
)
340 int count
= gdb_bfd_count_sections (objfile
->obfd
);
342 objfile
->sections
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
345 objfile
->sections_end
= (objfile
->sections
+ count
);
346 bfd_map_over_sections (objfile
->obfd
,
347 add_to_objfile_sections
, (void *) objfile
);
349 /* See gdb_bfd_section_index. */
350 add_to_objfile_sections_full (objfile
->obfd
, bfd_com_section_ptr
, objfile
, 1);
351 add_to_objfile_sections_full (objfile
->obfd
, bfd_und_section_ptr
, objfile
, 1);
352 add_to_objfile_sections_full (objfile
->obfd
, bfd_abs_section_ptr
, objfile
, 1);
353 add_to_objfile_sections_full (objfile
->obfd
, bfd_ind_section_ptr
, objfile
, 1);
356 /* Given a pointer to an initialized bfd (ABFD) and some flag bits,
357 initialize the new objfile as best we can and link it into the list
358 of all known objfiles.
360 NAME should contain original non-canonicalized filename or other
361 identifier as entered by user. If there is no better source use
362 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
363 NAME content is copied into returned objfile.
365 The FLAGS word contains various bits (OBJF_*) that can be taken as
366 requests for specific operations. Other bits like OBJF_SHARED are
367 simply copied through to the new objfile flags member. */
369 objfile::objfile (bfd
*abfd
, const char *name
, objfile_flags flags_
)
371 pspace (current_program_space
),
373 psymbol_cache (psymbol_bcache_init ())
375 const char *expanded_name
;
377 /* We could use obstack_specify_allocation here instead, but
378 gdb_obstack.h specifies the alloc/dealloc functions. */
379 obstack_init (&objfile_obstack
);
381 objfile_alloc_data (this);
383 gdb::unique_xmalloc_ptr
<char> name_holder
;
386 gdb_assert (abfd
== NULL
);
387 gdb_assert ((flags
& OBJF_NOT_FILENAME
) != 0);
388 expanded_name
= "<<anonymous objfile>>";
390 else if ((flags
& OBJF_NOT_FILENAME
) != 0
391 || is_target_filename (name
))
392 expanded_name
= name
;
395 name_holder
= gdb_abspath (name
);
396 expanded_name
= name_holder
.get ();
399 = (char *) obstack_copy0 (&objfile_obstack
,
401 strlen (expanded_name
));
403 /* Update the per-objfile information that comes from the bfd, ensuring
404 that any data that is reference is saved in the per-objfile data
410 mtime
= bfd_get_mtime (abfd
);
412 /* Build section table. */
413 build_objfile_section_table (this);
416 per_bfd
= get_objfile_bfd_data (this, abfd
);
418 terminate_minimal_symbol_table (this);
420 /* Add this file onto the tail of the linked list of other such files. */
422 if (object_files
== NULL
)
426 struct objfile
*last_one
;
428 for (last_one
= object_files
;
430 last_one
= last_one
->next
);
431 last_one
->next
= this;
434 /* Rebuild section map next time we need it. */
435 get_objfile_pspace_data (pspace
)->new_objfiles_available
= 1;
438 /* Retrieve the gdbarch associated with OBJFILE. */
441 get_objfile_arch (const struct objfile
*objfile
)
443 return objfile
->per_bfd
->gdbarch
;
446 /* If there is a valid and known entry point, function fills *ENTRY_P with it
447 and returns non-zero; otherwise it returns zero. */
450 entry_point_address_query (CORE_ADDR
*entry_p
)
452 if (symfile_objfile
== NULL
|| !symfile_objfile
->per_bfd
->ei
.entry_point_p
)
455 *entry_p
= (symfile_objfile
->per_bfd
->ei
.entry_point
456 + ANOFFSET (symfile_objfile
->section_offsets
,
457 symfile_objfile
->per_bfd
->ei
.the_bfd_section_index
));
462 /* Get current entry point address. Call error if it is not known. */
465 entry_point_address (void)
469 if (!entry_point_address_query (&retval
))
470 error (_("Entry point address is not known."));
475 /* Iterator on PARENT and every separate debug objfile of PARENT.
476 The usage pattern is:
477 for (objfile = parent;
479 objfile = objfile_separate_debug_iterate (parent, objfile))
484 objfile_separate_debug_iterate (const struct objfile
*parent
,
485 const struct objfile
*objfile
)
489 /* If any, return the first child. */
490 res
= objfile
->separate_debug_objfile
;
494 /* Common case where there is no separate debug objfile. */
495 if (objfile
== parent
)
498 /* Return the brother if any. Note that we don't iterate on brothers of
500 res
= objfile
->separate_debug_objfile_link
;
504 for (res
= objfile
->separate_debug_objfile_backlink
;
506 res
= res
->separate_debug_objfile_backlink
)
508 gdb_assert (res
!= NULL
);
509 if (res
->separate_debug_objfile_link
)
510 return res
->separate_debug_objfile_link
;
515 /* Put one object file before a specified on in the global list.
516 This can be used to make sure an object file is destroyed before
517 another when using all_objfiles_safe to free all objfiles. */
519 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
521 struct objfile
**objp
;
523 unlink_objfile (objfile
);
525 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
527 if (*objp
== before_this
)
529 objfile
->next
= *objp
;
535 internal_error (__FILE__
, __LINE__
,
536 _("put_objfile_before: before objfile not in list"));
539 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
542 It is not a bug, or error, to call this function if OBJFILE is not known
543 to be in the current list. This is done in the case of mapped objfiles,
544 for example, just to ensure that the mapped objfile doesn't appear twice
545 in the list. Since the list is threaded, linking in a mapped objfile
546 twice would create a circular list.
548 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
549 unlinking it, just to ensure that we have completely severed any linkages
550 between the OBJFILE and the list. */
553 unlink_objfile (struct objfile
*objfile
)
555 struct objfile
**objpp
;
557 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
559 if (*objpp
== objfile
)
561 *objpp
= (*objpp
)->next
;
562 objfile
->next
= NULL
;
567 internal_error (__FILE__
, __LINE__
,
568 _("unlink_objfile: objfile already unlinked"));
571 /* Add OBJFILE as a separate debug objfile of PARENT. */
574 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
576 gdb_assert (objfile
&& parent
);
578 /* Must not be already in a list. */
579 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
580 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
581 gdb_assert (objfile
->separate_debug_objfile
== NULL
);
582 gdb_assert (parent
->separate_debug_objfile_backlink
== NULL
);
583 gdb_assert (parent
->separate_debug_objfile_link
== NULL
);
585 objfile
->separate_debug_objfile_backlink
= parent
;
586 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
587 parent
->separate_debug_objfile
= objfile
;
589 /* Put the separate debug object before the normal one, this is so that
590 usage of all_objfiles_safe will stay safe. */
591 put_objfile_before (objfile
, parent
);
594 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
598 free_objfile_separate_debug (struct objfile
*objfile
)
600 struct objfile
*child
;
602 for (child
= objfile
->separate_debug_objfile
; child
;)
604 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
610 /* Destroy an objfile and all the symtabs and psymtabs under it. */
614 /* First notify observers that this objfile is about to be freed. */
615 gdb::observers::free_objfile
.notify (this);
617 /* Free all separate debug objfiles. */
618 free_objfile_separate_debug (this);
620 if (separate_debug_objfile_backlink
)
622 /* We freed the separate debug file, make sure the base objfile
623 doesn't reference it. */
624 struct objfile
*child
;
626 child
= separate_debug_objfile_backlink
->separate_debug_objfile
;
630 /* THIS is the first child. */
631 separate_debug_objfile_backlink
->separate_debug_objfile
=
632 separate_debug_objfile_link
;
636 /* Find THIS in the list. */
639 if (child
->separate_debug_objfile_link
== this)
641 child
->separate_debug_objfile_link
=
642 separate_debug_objfile_link
;
645 child
= child
->separate_debug_objfile_link
;
651 /* Remove any references to this objfile in the global value
653 preserve_values (this);
655 /* It still may reference data modules have associated with the objfile and
656 the symbol file data. */
657 forget_cached_source_info_for_objfile (this);
659 breakpoint_free_objfile (this);
660 btrace_free_objfile (this);
662 /* First do any symbol file specific actions required when we are
663 finished with a particular symbol file. Note that if the objfile
664 is using reusable symbol information (via mmalloc) then each of
665 these routines is responsible for doing the correct thing, either
666 freeing things which are valid only during this particular gdb
667 execution, or leaving them to be reused during the next one. */
670 (*sf
->sym_finish
) (this);
672 /* Discard any data modules have associated with the objfile. The function
673 still may reference obfd. */
674 objfile_free_data (this);
677 gdb_bfd_unref (obfd
);
679 free_objfile_per_bfd_storage (per_bfd
);
681 /* Remove it from the chain of all objfiles. */
683 unlink_objfile (this);
685 if (this == symfile_objfile
)
686 symfile_objfile
= NULL
;
688 /* Before the symbol table code was redone to make it easier to
689 selectively load and remove information particular to a specific
690 linkage unit, gdb used to do these things whenever the monolithic
691 symbol table was blown away. How much still needs to be done
692 is unknown, but we play it safe for now and keep each action until
693 it is shown to be no longer needed. */
695 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
696 for example), so we need to call this here. */
697 clear_pc_function_cache ();
699 /* Clear globals which might have pointed into a removed objfile.
700 FIXME: It's not clear which of these are supposed to persist
701 between expressions and which ought to be reset each time. */
702 expression_context_block
= NULL
;
703 innermost_block
.reset ();
705 /* Check to see if the current_source_symtab belongs to this objfile,
706 and if so, call clear_current_source_symtab_and_line. */
709 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
711 if (cursal
.symtab
&& SYMTAB_OBJFILE (cursal
.symtab
) == this)
712 clear_current_source_symtab_and_line ();
715 /* Free the obstacks for non-reusable objfiles. */
716 psymbol_bcache_free (psymbol_cache
);
717 obstack_free (&objfile_obstack
, 0);
719 /* Rebuild section map next time we need it. */
720 get_objfile_pspace_data (pspace
)->section_map_dirty
= 1;
722 /* Free the map for static links. There's no need to free static link
723 themselves since they were allocated on the objstack. */
724 if (static_links
!= NULL
)
725 htab_delete (static_links
);
728 /* Free all the object files at once and clean up their users. */
731 free_all_objfiles (void)
735 /* Any objfile referencewould become stale. */
736 for (so
= master_so_list (); so
; so
= so
->next
)
737 gdb_assert (so
->objfile
== NULL
);
739 for (objfile
*objfile
: all_objfiles_safe (current_program_space
))
741 clear_symtab_users (0);
744 /* A helper function for objfile_relocate1 that relocates a single
748 relocate_one_symbol (struct symbol
*sym
, struct objfile
*objfile
,
749 struct section_offsets
*delta
)
751 fixup_symbol_section (sym
, objfile
);
753 /* The RS6000 code from which this was taken skipped
754 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
755 But I'm leaving out that test, on the theory that
756 they can't possibly pass the tests below. */
757 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
758 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
759 && SYMBOL_SECTION (sym
) >= 0)
761 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (delta
, SYMBOL_SECTION (sym
));
765 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
766 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
767 Return non-zero iff any change happened. */
770 objfile_relocate1 (struct objfile
*objfile
,
771 const struct section_offsets
*new_offsets
)
773 struct section_offsets
*delta
=
774 ((struct section_offsets
*)
775 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
777 int something_changed
= 0;
779 for (int i
= 0; i
< objfile
->num_sections
; ++i
)
782 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
783 if (ANOFFSET (delta
, i
) != 0)
784 something_changed
= 1;
786 if (!something_changed
)
789 /* OK, get all the symtabs. */
791 for (compunit_symtab
*cust
: objfile_compunits (objfile
))
793 for (symtab
*s
: compunit_filetabs (cust
))
797 /* First the line table. */
798 l
= SYMTAB_LINETABLE (s
);
801 for (int i
= 0; i
< l
->nitems
; ++i
)
802 l
->item
[i
].pc
+= ANOFFSET (delta
,
803 COMPUNIT_BLOCK_LINE_SECTION
809 for (compunit_symtab
*cust
: objfile_compunits (objfile
))
811 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (cust
);
812 int block_line_section
= COMPUNIT_BLOCK_LINE_SECTION (cust
);
814 if (BLOCKVECTOR_MAP (bv
))
815 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
816 ANOFFSET (delta
, block_line_section
));
818 for (int i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
822 struct dict_iterator iter
;
824 b
= BLOCKVECTOR_BLOCK (bv
, i
);
825 BLOCK_START (b
) += ANOFFSET (delta
, block_line_section
);
826 BLOCK_END (b
) += ANOFFSET (delta
, block_line_section
);
828 if (BLOCK_RANGES (b
) != nullptr)
829 for (int j
= 0; j
< BLOCK_NRANGES (b
); j
++)
831 BLOCK_RANGE_START (b
, j
)
832 += ANOFFSET (delta
, block_line_section
);
833 BLOCK_RANGE_END (b
, j
) += ANOFFSET (delta
,
837 /* We only want to iterate over the local symbols, not any
838 symbols in included symtabs. */
839 ALL_DICT_SYMBOLS (BLOCK_DICT (b
), iter
, sym
)
841 relocate_one_symbol (sym
, objfile
, delta
);
847 /* This stores relocated addresses and so must be cleared. This
848 will cause it to be recreated on demand. */
849 objfile
->psymbol_map
.clear ();
851 /* Relocate isolated symbols. */
855 for (iter
= objfile
->template_symbols
; iter
; iter
= iter
->hash_next
)
856 relocate_one_symbol (iter
, objfile
, delta
);
862 for (i
= 0; i
< objfile
->num_sections
; ++i
)
863 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
866 /* Rebuild section map next time we need it. */
867 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
869 /* Update the table in exec_ops, used to read memory. */
870 struct obj_section
*s
;
871 ALL_OBJFILE_OSECTIONS (objfile
, s
)
873 int idx
= s
- objfile
->sections
;
875 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
876 obj_section_addr (s
));
883 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
884 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
886 The number and ordering of sections does differ between the two objfiles.
887 Only their names match. Also the file offsets will differ (objfile being
888 possibly prelinked but separate_debug_objfile is probably not prelinked) but
889 the in-memory absolute address as specified by NEW_OFFSETS must match both
893 objfile_relocate (struct objfile
*objfile
,
894 const struct section_offsets
*new_offsets
)
896 struct objfile
*debug_objfile
;
899 changed
|= objfile_relocate1 (objfile
, new_offsets
);
901 for (debug_objfile
= objfile
->separate_debug_objfile
;
903 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
905 section_addr_info objfile_addrs
906 = build_section_addr_info_from_objfile (objfile
);
908 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
909 relative ones must be already created according to debug_objfile. */
911 addr_info_make_relative (&objfile_addrs
, debug_objfile
->obfd
);
913 gdb_assert (debug_objfile
->num_sections
914 == gdb_bfd_count_sections (debug_objfile
->obfd
));
915 std::vector
<struct section_offsets
>
916 new_debug_offsets (SIZEOF_N_SECTION_OFFSETS (debug_objfile
->num_sections
));
917 relative_addr_info_to_section_offsets (new_debug_offsets
.data (),
918 debug_objfile
->num_sections
,
921 changed
|= objfile_relocate1 (debug_objfile
, new_debug_offsets
.data ());
924 /* Relocate breakpoints as necessary, after things are relocated. */
926 breakpoint_re_set ();
929 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
931 Return non-zero iff any change happened. */
934 objfile_rebase1 (struct objfile
*objfile
, CORE_ADDR slide
)
936 struct section_offsets
*new_offsets
=
937 ((struct section_offsets
*)
938 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
941 for (i
= 0; i
< objfile
->num_sections
; ++i
)
942 new_offsets
->offsets
[i
] = slide
;
944 return objfile_relocate1 (objfile
, new_offsets
);
947 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
948 SEPARATE_DEBUG_OBJFILEs. */
951 objfile_rebase (struct objfile
*objfile
, CORE_ADDR slide
)
953 struct objfile
*debug_objfile
;
956 changed
|= objfile_rebase1 (objfile
, slide
);
958 for (debug_objfile
= objfile
->separate_debug_objfile
;
960 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
961 changed
|= objfile_rebase1 (debug_objfile
, slide
);
963 /* Relocate breakpoints as necessary, after things are relocated. */
965 breakpoint_re_set ();
968 /* Return non-zero if OBJFILE has partial symbols. */
971 objfile_has_partial_symbols (struct objfile
*objfile
)
976 /* If we have not read psymbols, but we have a function capable of reading
977 them, then that is an indication that they are in fact available. Without
978 this function the symbols may have been already read in but they also may
979 not be present in this objfile. */
980 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0
981 && objfile
->sf
->sym_read_psymbols
!= NULL
)
984 return objfile
->sf
->qf
->has_symbols (objfile
);
987 /* Return non-zero if OBJFILE has full symbols. */
990 objfile_has_full_symbols (struct objfile
*objfile
)
992 return objfile
->compunit_symtabs
!= NULL
;
995 /* Return non-zero if OBJFILE has full or partial symbols, either directly
996 or through a separate debug file. */
999 objfile_has_symbols (struct objfile
*objfile
)
1003 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
1004 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
1010 /* Many places in gdb want to test just to see if we have any partial
1011 symbols available. This function returns zero if none are currently
1012 available, nonzero otherwise. */
1015 have_partial_symbols (void)
1017 for (objfile
*ofp
: all_objfiles (current_program_space
))
1019 if (objfile_has_partial_symbols (ofp
))
1025 /* Many places in gdb want to test just to see if we have any full
1026 symbols available. This function returns zero if none are currently
1027 available, nonzero otherwise. */
1030 have_full_symbols (void)
1032 for (objfile
*ofp
: all_objfiles (current_program_space
))
1034 if (objfile_has_full_symbols (ofp
))
1041 /* This operations deletes all objfile entries that represent solibs that
1042 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1046 objfile_purge_solibs (void)
1048 for (objfile
*objf
: all_objfiles_safe (current_program_space
))
1050 /* We assume that the solib package has been purged already, or will
1053 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
1059 /* Many places in gdb want to test just to see if we have any minimal
1060 symbols available. This function returns zero if none are currently
1061 available, nonzero otherwise. */
1064 have_minimal_symbols (void)
1066 for (objfile
*ofp
: all_objfiles (current_program_space
))
1068 if (ofp
->per_bfd
->minimal_symbol_count
> 0)
1076 /* Qsort comparison function. */
1079 qsort_cmp (const void *a
, const void *b
)
1081 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
1082 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
1083 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1084 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1086 if (sect1_addr
< sect2_addr
)
1088 else if (sect1_addr
> sect2_addr
)
1092 /* Sections are at the same address. This could happen if
1093 A) we have an objfile and a separate debuginfo.
1094 B) we are confused, and have added sections without proper relocation,
1095 or something like that. */
1097 const struct objfile
*const objfile1
= sect1
->objfile
;
1098 const struct objfile
*const objfile2
= sect2
->objfile
;
1100 if (objfile1
->separate_debug_objfile
== objfile2
1101 || objfile2
->separate_debug_objfile
== objfile1
)
1103 /* Case A. The ordering doesn't matter: separate debuginfo files
1104 will be filtered out later. */
1109 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1110 triage. This section could be slow (since we iterate over all
1111 objfiles in each call to qsort_cmp), but this shouldn't happen
1112 very often (GDB is already in a confused state; one hopes this
1113 doesn't happen at all). If you discover that significant time is
1114 spent in the loops below, do 'set complaints 100' and examine the
1115 resulting complaints. */
1117 if (objfile1
== objfile2
)
1119 /* Both sections came from the same objfile. We are really confused.
1120 Sort on sequence order of sections within the objfile. */
1122 const struct obj_section
*osect
;
1124 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1127 else if (osect
== sect2
)
1130 /* We should have found one of the sections before getting here. */
1131 gdb_assert_not_reached ("section not found");
1135 /* Sort on sequence number of the objfile in the chain. */
1137 for (objfile
*objfile
: all_objfiles (current_program_space
))
1138 if (objfile
== objfile1
)
1140 else if (objfile
== objfile2
)
1143 /* We should have found one of the objfiles before getting here. */
1144 gdb_assert_not_reached ("objfile not found");
1149 gdb_assert_not_reached ("unexpected code path");
1153 /* Select "better" obj_section to keep. We prefer the one that came from
1154 the real object, rather than the one from separate debuginfo.
1155 Most of the time the two sections are exactly identical, but with
1156 prelinking the .rel.dyn section in the real object may have different
1159 static struct obj_section
*
1160 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
1162 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
1163 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
1164 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
1165 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
1166 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
1168 if (a
->objfile
->separate_debug_objfile
!= NULL
)
1173 /* Return 1 if SECTION should be inserted into the section map.
1174 We want to insert only non-overlay and non-TLS section. */
1177 insert_section_p (const struct bfd
*abfd
,
1178 const struct bfd_section
*section
)
1180 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
1182 if (overlay_debugging
&& lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
1183 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
1184 /* This is an overlay section. IN_MEMORY check is needed to avoid
1185 discarding sections from the "system supplied DSO" (aka vdso)
1186 on some Linux systems (e.g. Fedora 11). */
1188 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
1189 /* This is a TLS section. */
1195 /* Filter out overlapping sections where one section came from the real
1196 objfile, and the other from a separate debuginfo file.
1197 Return the size of table after redundant sections have been eliminated. */
1200 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1204 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1206 struct obj_section
*const sect1
= map
[i
];
1207 struct obj_section
*const sect2
= map
[i
+ 1];
1208 const struct objfile
*const objfile1
= sect1
->objfile
;
1209 const struct objfile
*const objfile2
= sect2
->objfile
;
1210 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1211 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1213 if (sect1_addr
== sect2_addr
1214 && (objfile1
->separate_debug_objfile
== objfile2
1215 || objfile2
->separate_debug_objfile
== objfile1
))
1217 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1226 gdb_assert (i
== map_size
- 1);
1230 /* The map should not have shrunk to less than half the original size. */
1231 gdb_assert (map_size
/ 2 <= j
);
1236 /* Filter out overlapping sections, issuing a warning if any are found.
1237 Overlapping sections could really be overlay sections which we didn't
1238 classify as such in insert_section_p, or we could be dealing with a
1242 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1246 for (i
= 0, j
= 0; i
< map_size
- 1; )
1251 for (k
= i
+ 1; k
< map_size
; k
++)
1253 struct obj_section
*const sect1
= map
[i
];
1254 struct obj_section
*const sect2
= map
[k
];
1255 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1256 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1257 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1259 gdb_assert (sect1_addr
<= sect2_addr
);
1261 if (sect1_endaddr
<= sect2_addr
)
1265 /* We have an overlap. Report it. */
1267 struct objfile
*const objf1
= sect1
->objfile
;
1268 struct objfile
*const objf2
= sect2
->objfile
;
1270 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1271 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1273 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1275 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1277 complaint (_("unexpected overlap between:\n"
1278 " (A) section `%s' from `%s' [%s, %s)\n"
1279 " (B) section `%s' from `%s' [%s, %s).\n"
1280 "Will ignore section B"),
1281 bfd_section_name (abfd1
, bfds1
), objfile_name (objf1
),
1282 paddress (gdbarch
, sect1_addr
),
1283 paddress (gdbarch
, sect1_endaddr
),
1284 bfd_section_name (abfd2
, bfds2
), objfile_name (objf2
),
1285 paddress (gdbarch
, sect2_addr
),
1286 paddress (gdbarch
, sect2_endaddr
));
1294 gdb_assert (i
== map_size
- 1);
1302 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1303 TLS, overlay and overlapping sections. */
1306 update_section_map (struct program_space
*pspace
,
1307 struct obj_section
***pmap
, int *pmap_size
)
1309 struct objfile_pspace_info
*pspace_info
;
1310 int alloc_size
, map_size
, i
;
1311 struct obj_section
*s
, **map
;
1313 pspace_info
= get_objfile_pspace_data (pspace
);
1314 gdb_assert (pspace_info
->section_map_dirty
!= 0
1315 || pspace_info
->new_objfiles_available
!= 0);
1321 for (objfile
*objfile
: all_objfiles (pspace
))
1322 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1323 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1326 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1327 if (alloc_size
== 0)
1334 map
= XNEWVEC (struct obj_section
*, alloc_size
);
1337 for (objfile
*objfile
: all_objfiles (pspace
))
1338 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1339 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1342 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1343 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1344 map_size
= filter_overlapping_sections(map
, map_size
);
1346 if (map_size
< alloc_size
)
1347 /* Some sections were eliminated. Trim excess space. */
1348 map
= XRESIZEVEC (struct obj_section
*, map
, map_size
);
1350 gdb_assert (alloc_size
== map_size
);
1353 *pmap_size
= map_size
;
1356 /* Bsearch comparison function. */
1359 bsearch_cmp (const void *key
, const void *elt
)
1361 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1362 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1364 if (pc
< obj_section_addr (section
))
1366 if (pc
< obj_section_endaddr (section
))
1371 /* Returns a section whose range includes PC or NULL if none found. */
1373 struct obj_section
*
1374 find_pc_section (CORE_ADDR pc
)
1376 struct objfile_pspace_info
*pspace_info
;
1377 struct obj_section
*s
, **sp
;
1379 /* Check for mapped overlay section first. */
1380 s
= find_pc_mapped_section (pc
);
1384 pspace_info
= get_objfile_pspace_data (current_program_space
);
1385 if (pspace_info
->section_map_dirty
1386 || (pspace_info
->new_objfiles_available
1387 && !pspace_info
->inhibit_updates
))
1389 update_section_map (current_program_space
,
1390 &pspace_info
->sections
,
1391 &pspace_info
->num_sections
);
1393 /* Don't need updates to section map until objfiles are added,
1394 removed or relocated. */
1395 pspace_info
->new_objfiles_available
= 0;
1396 pspace_info
->section_map_dirty
= 0;
1399 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1400 bsearch be non-NULL. */
1401 if (pspace_info
->sections
== NULL
)
1403 gdb_assert (pspace_info
->num_sections
== 0);
1407 sp
= (struct obj_section
**) bsearch (&pc
,
1408 pspace_info
->sections
,
1409 pspace_info
->num_sections
,
1410 sizeof (*pspace_info
->sections
),
1418 /* Return non-zero if PC is in a section called NAME. */
1421 pc_in_section (CORE_ADDR pc
, const char *name
)
1423 struct obj_section
*s
;
1426 s
= find_pc_section (pc
);
1429 && s
->the_bfd_section
->name
!= NULL
1430 && strcmp (s
->the_bfd_section
->name
, name
) == 0);
1435 /* Set section_map_dirty so section map will be rebuilt next time it
1436 is used. Called by reread_symbols. */
1439 objfiles_changed (void)
1441 /* Rebuild section map next time we need it. */
1442 get_objfile_pspace_data (current_program_space
)->section_map_dirty
= 1;
1445 /* See comments in objfiles.h. */
1447 scoped_restore_tmpl
<int>
1448 inhibit_section_map_updates (struct program_space
*pspace
)
1450 return scoped_restore_tmpl
<int>
1451 (&get_objfile_pspace_data (pspace
)->inhibit_updates
, 1);
1454 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1458 is_addr_in_objfile (CORE_ADDR addr
, const struct objfile
*objfile
)
1460 struct obj_section
*osect
;
1462 if (objfile
== NULL
)
1465 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1467 if (section_is_overlay (osect
) && !section_is_mapped (osect
))
1470 if (obj_section_addr (osect
) <= addr
1471 && addr
< obj_section_endaddr (osect
))
1478 shared_objfile_contains_address_p (struct program_space
*pspace
,
1481 for (objfile
*objfile
: all_objfiles (pspace
))
1483 if ((objfile
->flags
& OBJF_SHARED
) != 0
1484 && is_addr_in_objfile (address
, objfile
))
1491 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1492 gdbarch method. It is equivalent to use the all_objfiles iterable,
1493 searching the objfiles in the order they are stored internally,
1494 ignoring CURRENT_OBJFILE.
1496 On most platorms, it should be close enough to doing the best
1497 we can without some knowledge specific to the architecture. */
1500 default_iterate_over_objfiles_in_search_order
1501 (struct gdbarch
*gdbarch
,
1502 iterate_over_objfiles_in_search_order_cb_ftype
*cb
,
1503 void *cb_data
, struct objfile
*current_objfile
)
1507 for (objfile
*objfile
: all_objfiles (current_program_space
))
1509 stop
= cb (objfile
, cb_data
);
1515 /* See objfiles.h. */
1518 objfile_name (const struct objfile
*objfile
)
1520 if (objfile
->obfd
!= NULL
)
1521 return bfd_get_filename (objfile
->obfd
);
1523 return objfile
->original_name
;
1526 /* See objfiles.h. */
1529 objfile_filename (const struct objfile
*objfile
)
1531 if (objfile
->obfd
!= NULL
)
1532 return bfd_get_filename (objfile
->obfd
);
1537 /* See objfiles.h. */
1540 objfile_debug_name (const struct objfile
*objfile
)
1542 return lbasename (objfile
->original_name
);
1545 /* See objfiles.h. */
1548 objfile_flavour_name (struct objfile
*objfile
)
1550 if (objfile
->obfd
!= NULL
)
1551 return bfd_flavour_name (bfd_get_flavour (objfile
->obfd
));
1556 _initialize_objfiles (void)
1558 objfiles_pspace_data
1559 = register_program_space_data_with_cleanup (NULL
,
1560 objfiles_pspace_data_cleanup
);
1562 objfiles_bfd_data
= register_bfd_data_with_cleanup (NULL
,
1563 objfile_bfd_data_free
);