1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* This file contains support routines for creating, manipulating, and
23 destroying objfile structures. */
26 #include "bfd.h" /* Binary File Description */
30 #include "gdb-stabs.h"
33 #include "expression.h"
34 #include "parser-defs.h"
36 #include "gdb_assert.h"
37 #include <sys/types.h>
40 #include "gdb_obstack.h"
44 #include "breakpoint.h"
46 #include "dictionary.h"
49 #include "arch-utils.h"
52 #include "complaints.h"
58 /* Keep a registry of per-objfile data-pointers required by other GDB
61 DEFINE_REGISTRY (objfile
, REGISTRY_ACCESS_FIELD
)
63 /* Externally visible variables that are owned by this module.
64 See declarations in objfile.h for more info. */
66 struct objfile_pspace_info
68 struct obj_section
**sections
;
71 /* Nonzero if object files have been added since the section map
73 int new_objfiles_available
;
75 /* Nonzero if the section map MUST be updated before use. */
76 int section_map_dirty
;
78 /* Nonzero if section map updates should be inhibited if possible. */
82 /* Per-program-space data key. */
83 static const struct program_space_data
*objfiles_pspace_data
;
86 objfiles_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
88 struct objfile_pspace_info
*info
= arg
;
90 xfree (info
->sections
);
94 /* Get the current svr4 data. If none is found yet, add it now. This
95 function always returns a valid object. */
97 static struct objfile_pspace_info
*
98 get_objfile_pspace_data (struct program_space
*pspace
)
100 struct objfile_pspace_info
*info
;
102 info
= program_space_data (pspace
, objfiles_pspace_data
);
105 info
= XZALLOC (struct objfile_pspace_info
);
106 set_program_space_data (pspace
, objfiles_pspace_data
, info
);
114 /* Per-BFD data key. */
116 static const struct bfd_data
*objfiles_bfd_data
;
118 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
119 NULL, and it already has a per-BFD storage object, use that.
120 Otherwise, allocate a new per-BFD storage object. If ABFD is not
121 NULL, the object is allocated on the BFD; otherwise it is allocated
122 on OBJFILE's obstack. Note that it is not safe to call this
123 multiple times for a given OBJFILE -- it can only be called when
124 allocating or re-initializing OBJFILE. */
126 static struct objfile_per_bfd_storage
*
127 get_objfile_bfd_data (struct objfile
*objfile
, struct bfd
*abfd
)
129 struct objfile_per_bfd_storage
*storage
= NULL
;
132 storage
= bfd_data (abfd
, objfiles_bfd_data
);
136 /* If the object requires gdb to do relocations, we simply fall
137 back to not sharing data across users. These cases are rare
138 enough that this seems reasonable. */
139 if (abfd
!= NULL
&& !gdb_bfd_requires_relocations (abfd
))
141 storage
= bfd_zalloc (abfd
, sizeof (struct objfile_per_bfd_storage
));
142 set_bfd_data (abfd
, objfiles_bfd_data
, storage
);
145 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
146 struct objfile_per_bfd_storage
);
148 /* Look up the gdbarch associated with the BFD. */
150 storage
->gdbarch
= gdbarch_from_bfd (abfd
);
152 obstack_init (&storage
->storage_obstack
);
153 storage
->filename_cache
= bcache_xmalloc (NULL
, NULL
);
154 storage
->macro_cache
= bcache_xmalloc (NULL
, NULL
);
163 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage
*storage
)
165 bcache_xfree (storage
->filename_cache
);
166 bcache_xfree (storage
->macro_cache
);
167 if (storage
->demangled_names_hash
)
168 htab_delete (storage
->demangled_names_hash
);
169 obstack_free (&storage
->storage_obstack
, 0);
172 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
173 cleanup function to the BFD registry. */
176 objfile_bfd_data_free (struct bfd
*unused
, void *d
)
178 free_objfile_per_bfd_storage (d
);
181 /* See objfiles.h. */
184 set_objfile_per_bfd (struct objfile
*objfile
)
186 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, objfile
->obfd
);
191 /* Called via bfd_map_over_sections to build up the section table that
192 the objfile references. The objfile contains pointers to the start
193 of the table (objfile->sections) and to the first location after
194 the end of the table (objfile->sections_end). */
197 add_to_objfile_sections_full (struct bfd
*abfd
, struct bfd_section
*asect
,
198 struct objfile
*objfile
, int force
)
200 struct obj_section
*section
;
206 aflag
= bfd_get_section_flags (abfd
, asect
);
207 if (!(aflag
& SEC_ALLOC
))
211 section
= &objfile
->sections
[gdb_bfd_section_index (abfd
, asect
)];
212 section
->objfile
= objfile
;
213 section
->the_bfd_section
= asect
;
214 section
->ovly_mapped
= 0;
218 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
221 add_to_objfile_sections_full (abfd
, asect
, objfilep
, 0);
224 /* Builds a section table for OBJFILE.
226 Note that the OFFSET and OVLY_MAPPED in each table entry are
227 initialized to zero. */
230 build_objfile_section_table (struct objfile
*objfile
)
232 int count
= gdb_bfd_count_sections (objfile
->obfd
);
234 objfile
->sections
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
237 objfile
->sections_end
= (objfile
->sections
+ count
);
238 bfd_map_over_sections (objfile
->obfd
,
239 add_to_objfile_sections
, (void *) objfile
);
241 /* See gdb_bfd_section_index. */
242 add_to_objfile_sections_full (objfile
->obfd
, bfd_com_section_ptr
, objfile
, 1);
243 add_to_objfile_sections_full (objfile
->obfd
, bfd_und_section_ptr
, objfile
, 1);
244 add_to_objfile_sections_full (objfile
->obfd
, bfd_abs_section_ptr
, objfile
, 1);
245 add_to_objfile_sections_full (objfile
->obfd
, bfd_ind_section_ptr
, objfile
, 1);
248 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
249 allocate a new objfile struct, fill it in as best we can, link it
250 into the list of all known objfiles, and return a pointer to the
253 NAME should contain original non-canonicalized filename or other
254 identifier as entered by user. If there is no better source use
255 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
256 NAME content is copied into returned objfile.
258 The FLAGS word contains various bits (OBJF_*) that can be taken as
259 requests for specific operations. Other bits like OBJF_SHARED are
260 simply copied through to the new objfile flags member. */
262 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
263 by jv-lang.c, to create an artificial objfile used to hold
264 information about dynamically-loaded Java classes. Unfortunately,
265 that branch of this function doesn't get tested very frequently, so
266 it's prone to breakage. (E.g. at one time the name was set to NULL
267 in that situation, which broke a loop over all names in the dynamic
268 library loader.) If you change this function, please try to leave
269 things in a consistent state even if abfd is NULL. */
272 allocate_objfile (bfd
*abfd
, const char *name
, int flags
)
274 struct objfile
*objfile
;
277 objfile
= (struct objfile
*) xzalloc (sizeof (struct objfile
));
278 objfile
->psymbol_cache
= psymbol_bcache_init ();
279 /* We could use obstack_specify_allocation here instead, but
280 gdb_obstack.h specifies the alloc/dealloc functions. */
281 obstack_init (&objfile
->objfile_obstack
);
282 terminate_minimal_symbol_table (objfile
);
284 objfile_alloc_data (objfile
);
288 gdb_assert (abfd
== NULL
);
289 gdb_assert ((flags
& OBJF_NOT_FILENAME
) != 0);
290 expanded_name
= xstrdup ("<<anonymous objfile>>");
292 else if ((flags
& OBJF_NOT_FILENAME
) != 0)
293 expanded_name
= xstrdup (name
);
295 expanded_name
= gdb_abspath (name
);
296 objfile
->original_name
= obstack_copy0 (&objfile
->objfile_obstack
,
298 strlen (expanded_name
));
299 xfree (expanded_name
);
301 /* Update the per-objfile information that comes from the bfd, ensuring
302 that any data that is reference is saved in the per-objfile data
305 /* Update the per-objfile information that comes from the bfd, ensuring
306 that any data that is reference is saved in the per-objfile data
309 objfile
->obfd
= abfd
;
313 objfile
->mtime
= bfd_get_mtime (abfd
);
315 /* Build section table. */
316 build_objfile_section_table (objfile
);
319 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, abfd
);
320 objfile
->pspace
= current_program_space
;
322 /* Initialize the section indexes for this objfile, so that we can
323 later detect if they are used w/o being properly assigned to. */
325 objfile
->sect_index_text
= -1;
326 objfile
->sect_index_data
= -1;
327 objfile
->sect_index_bss
= -1;
328 objfile
->sect_index_rodata
= -1;
330 /* Add this file onto the tail of the linked list of other such files. */
332 objfile
->next
= NULL
;
333 if (object_files
== NULL
)
334 object_files
= objfile
;
337 struct objfile
*last_one
;
339 for (last_one
= object_files
;
341 last_one
= last_one
->next
);
342 last_one
->next
= objfile
;
345 /* Save passed in flag bits. */
346 objfile
->flags
|= flags
;
348 /* Rebuild section map next time we need it. */
349 get_objfile_pspace_data (objfile
->pspace
)->new_objfiles_available
= 1;
354 /* Retrieve the gdbarch associated with OBJFILE. */
356 get_objfile_arch (struct objfile
*objfile
)
358 return objfile
->per_bfd
->gdbarch
;
361 /* If there is a valid and known entry point, function fills *ENTRY_P with it
362 and returns non-zero; otherwise it returns zero. */
365 entry_point_address_query (CORE_ADDR
*entry_p
)
367 if (symfile_objfile
== NULL
|| !symfile_objfile
->ei
.entry_point_p
)
370 *entry_p
= symfile_objfile
->ei
.entry_point
;
375 /* Get current entry point address. Call error if it is not known. */
378 entry_point_address (void)
382 if (!entry_point_address_query (&retval
))
383 error (_("Entry point address is not known."));
388 /* Iterator on PARENT and every separate debug objfile of PARENT.
389 The usage pattern is:
390 for (objfile = parent;
392 objfile = objfile_separate_debug_iterate (parent, objfile))
397 objfile_separate_debug_iterate (const struct objfile
*parent
,
398 const struct objfile
*objfile
)
402 /* If any, return the first child. */
403 res
= objfile
->separate_debug_objfile
;
407 /* Common case where there is no separate debug objfile. */
408 if (objfile
== parent
)
411 /* Return the brother if any. Note that we don't iterate on brothers of
413 res
= objfile
->separate_debug_objfile_link
;
417 for (res
= objfile
->separate_debug_objfile_backlink
;
419 res
= res
->separate_debug_objfile_backlink
)
421 gdb_assert (res
!= NULL
);
422 if (res
->separate_debug_objfile_link
)
423 return res
->separate_debug_objfile_link
;
428 /* Put one object file before a specified on in the global list.
429 This can be used to make sure an object file is destroyed before
430 another when using ALL_OBJFILES_SAFE to free all objfiles. */
432 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
434 struct objfile
**objp
;
436 unlink_objfile (objfile
);
438 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
440 if (*objp
== before_this
)
442 objfile
->next
= *objp
;
448 internal_error (__FILE__
, __LINE__
,
449 _("put_objfile_before: before objfile not in list"));
452 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
455 It is not a bug, or error, to call this function if OBJFILE is not known
456 to be in the current list. This is done in the case of mapped objfiles,
457 for example, just to ensure that the mapped objfile doesn't appear twice
458 in the list. Since the list is threaded, linking in a mapped objfile
459 twice would create a circular list.
461 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
462 unlinking it, just to ensure that we have completely severed any linkages
463 between the OBJFILE and the list. */
466 unlink_objfile (struct objfile
*objfile
)
468 struct objfile
**objpp
;
470 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
472 if (*objpp
== objfile
)
474 *objpp
= (*objpp
)->next
;
475 objfile
->next
= NULL
;
480 internal_error (__FILE__
, __LINE__
,
481 _("unlink_objfile: objfile already unlinked"));
484 /* Add OBJFILE as a separate debug objfile of PARENT. */
487 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
489 gdb_assert (objfile
&& parent
);
491 /* Must not be already in a list. */
492 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
493 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
494 gdb_assert (objfile
->separate_debug_objfile
== NULL
);
495 gdb_assert (parent
->separate_debug_objfile_backlink
== NULL
);
496 gdb_assert (parent
->separate_debug_objfile_link
== NULL
);
498 objfile
->separate_debug_objfile_backlink
= parent
;
499 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
500 parent
->separate_debug_objfile
= objfile
;
502 /* Put the separate debug object before the normal one, this is so that
503 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
504 put_objfile_before (objfile
, parent
);
507 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
511 free_objfile_separate_debug (struct objfile
*objfile
)
513 struct objfile
*child
;
515 for (child
= objfile
->separate_debug_objfile
; child
;)
517 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
518 free_objfile (child
);
523 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
524 that as much as possible is allocated on the objfile_obstack
525 so that the memory can be efficiently freed.
527 Things which we do NOT free because they are not in malloc'd memory
528 or not in memory specific to the objfile include:
532 FIXME: If the objfile is using reusable symbol information (via mmalloc),
533 then we need to take into account the fact that more than one process
534 may be using the symbol information at the same time (when mmalloc is
535 extended to support cooperative locking). When more than one process
536 is using the mapped symbol info, we need to be more careful about when
537 we free objects in the reusable area. */
540 free_objfile (struct objfile
*objfile
)
542 /* First notify observers that this objfile is about to be freed. */
543 observer_notify_free_objfile (objfile
);
545 /* Free all separate debug objfiles. */
546 free_objfile_separate_debug (objfile
);
548 if (objfile
->separate_debug_objfile_backlink
)
550 /* We freed the separate debug file, make sure the base objfile
551 doesn't reference it. */
552 struct objfile
*child
;
554 child
= objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
;
556 if (child
== objfile
)
558 /* OBJFILE is the first child. */
559 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
=
560 objfile
->separate_debug_objfile_link
;
564 /* Find OBJFILE in the list. */
567 if (child
->separate_debug_objfile_link
== objfile
)
569 child
->separate_debug_objfile_link
=
570 objfile
->separate_debug_objfile_link
;
573 child
= child
->separate_debug_objfile_link
;
579 /* Remove any references to this objfile in the global value
581 preserve_values (objfile
);
583 /* It still may reference data modules have associated with the objfile and
584 the symbol file data. */
585 forget_cached_source_info_for_objfile (objfile
);
587 breakpoint_free_objfile (objfile
);
588 btrace_free_objfile (objfile
);
590 /* First do any symbol file specific actions required when we are
591 finished with a particular symbol file. Note that if the objfile
592 is using reusable symbol information (via mmalloc) then each of
593 these routines is responsible for doing the correct thing, either
594 freeing things which are valid only during this particular gdb
595 execution, or leaving them to be reused during the next one. */
597 if (objfile
->sf
!= NULL
)
599 (*objfile
->sf
->sym_finish
) (objfile
);
602 /* Discard any data modules have associated with the objfile. The function
603 still may reference objfile->obfd. */
604 objfile_free_data (objfile
);
607 gdb_bfd_unref (objfile
->obfd
);
609 free_objfile_per_bfd_storage (objfile
->per_bfd
);
611 /* Remove it from the chain of all objfiles. */
613 unlink_objfile (objfile
);
615 if (objfile
== symfile_objfile
)
616 symfile_objfile
= NULL
;
618 /* Before the symbol table code was redone to make it easier to
619 selectively load and remove information particular to a specific
620 linkage unit, gdb used to do these things whenever the monolithic
621 symbol table was blown away. How much still needs to be done
622 is unknown, but we play it safe for now and keep each action until
623 it is shown to be no longer needed. */
625 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
626 for example), so we need to call this here. */
627 clear_pc_function_cache ();
629 /* Clear globals which might have pointed into a removed objfile.
630 FIXME: It's not clear which of these are supposed to persist
631 between expressions and which ought to be reset each time. */
632 expression_context_block
= NULL
;
633 innermost_block
= NULL
;
635 /* Check to see if the current_source_symtab belongs to this objfile,
636 and if so, call clear_current_source_symtab_and_line. */
639 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
641 if (cursal
.symtab
&& cursal
.symtab
->objfile
== objfile
)
642 clear_current_source_symtab_and_line ();
645 if (objfile
->global_psymbols
.list
)
646 xfree (objfile
->global_psymbols
.list
);
647 if (objfile
->static_psymbols
.list
)
648 xfree (objfile
->static_psymbols
.list
);
649 /* Free the obstacks for non-reusable objfiles. */
650 psymbol_bcache_free (objfile
->psymbol_cache
);
651 obstack_free (&objfile
->objfile_obstack
, 0);
653 /* Rebuild section map next time we need it. */
654 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
656 /* The last thing we do is free the objfile struct itself. */
661 do_free_objfile_cleanup (void *obj
)
667 make_cleanup_free_objfile (struct objfile
*obj
)
669 return make_cleanup (do_free_objfile_cleanup
, obj
);
672 /* Free all the object files at once and clean up their users. */
675 free_all_objfiles (void)
677 struct objfile
*objfile
, *temp
;
680 /* Any objfile referencewould become stale. */
681 for (so
= master_so_list (); so
; so
= so
->next
)
682 gdb_assert (so
->objfile
== NULL
);
684 ALL_OBJFILES_SAFE (objfile
, temp
)
686 free_objfile (objfile
);
688 clear_symtab_users (0);
691 /* A helper function for objfile_relocate1 that relocates a single
695 relocate_one_symbol (struct symbol
*sym
, struct objfile
*objfile
,
696 struct section_offsets
*delta
)
698 fixup_symbol_section (sym
, objfile
);
700 /* The RS6000 code from which this was taken skipped
701 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
702 But I'm leaving out that test, on the theory that
703 they can't possibly pass the tests below. */
704 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
705 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
706 && SYMBOL_SECTION (sym
) >= 0)
708 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (delta
, SYMBOL_SECTION (sym
));
712 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
713 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
714 Return non-zero iff any change happened. */
717 objfile_relocate1 (struct objfile
*objfile
,
718 const struct section_offsets
*new_offsets
)
720 struct obj_section
*s
;
721 struct section_offsets
*delta
=
722 ((struct section_offsets
*)
723 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
726 int something_changed
= 0;
728 for (i
= 0; i
< objfile
->num_sections
; ++i
)
731 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
732 if (ANOFFSET (delta
, i
) != 0)
733 something_changed
= 1;
735 if (!something_changed
)
738 /* OK, get all the symtabs. */
742 ALL_OBJFILE_SYMTABS (objfile
, s
)
745 struct blockvector
*bv
;
748 /* First the line table. */
752 for (i
= 0; i
< l
->nitems
; ++i
)
753 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
756 /* Don't relocate a shared blockvector more than once. */
760 bv
= BLOCKVECTOR (s
);
761 if (BLOCKVECTOR_MAP (bv
))
762 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
763 ANOFFSET (delta
, s
->block_line_section
));
765 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
769 struct dict_iterator iter
;
771 b
= BLOCKVECTOR_BLOCK (bv
, i
);
772 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
773 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
775 /* We only want to iterate over the local symbols, not any
776 symbols in included symtabs. */
777 ALL_DICT_SYMBOLS (BLOCK_DICT (b
), iter
, sym
)
779 relocate_one_symbol (sym
, objfile
, delta
);
785 /* Relocate isolated symbols. */
789 for (iter
= objfile
->template_symbols
; iter
; iter
= iter
->hash_next
)
790 relocate_one_symbol (iter
, objfile
, delta
);
793 if (objfile
->psymtabs_addrmap
)
794 addrmap_relocate (objfile
->psymtabs_addrmap
,
795 ANOFFSET (delta
, SECT_OFF_TEXT (objfile
)));
798 objfile
->sf
->qf
->relocate (objfile
, new_offsets
, delta
);
801 struct minimal_symbol
*msym
;
803 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
804 if (SYMBOL_SECTION (msym
) >= 0)
805 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
807 /* Relocating different sections by different amounts may cause the symbols
808 to be out of order. */
809 msymbols_sort (objfile
);
811 if (objfile
->ei
.entry_point_p
)
813 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
814 only as a fallback. */
815 struct obj_section
*s
;
816 s
= find_pc_section (objfile
->ei
.entry_point
);
819 int idx
= gdb_bfd_section_index (objfile
->obfd
, s
->the_bfd_section
);
821 objfile
->ei
.entry_point
+= ANOFFSET (delta
, idx
);
824 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
830 for (i
= 0; i
< objfile
->num_sections
; ++i
)
831 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
834 /* Rebuild section map next time we need it. */
835 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
837 /* Update the table in exec_ops, used to read memory. */
838 ALL_OBJFILE_OSECTIONS (objfile
, s
)
840 int idx
= s
- objfile
->sections
;
842 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
843 obj_section_addr (s
));
846 /* Relocating probes. */
847 if (objfile
->sf
&& objfile
->sf
->sym_probe_fns
)
848 objfile
->sf
->sym_probe_fns
->sym_relocate_probe (objfile
,
855 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
856 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
858 The number and ordering of sections does differ between the two objfiles.
859 Only their names match. Also the file offsets will differ (objfile being
860 possibly prelinked but separate_debug_objfile is probably not prelinked) but
861 the in-memory absolute address as specified by NEW_OFFSETS must match both
865 objfile_relocate (struct objfile
*objfile
,
866 const struct section_offsets
*new_offsets
)
868 struct objfile
*debug_objfile
;
871 changed
|= objfile_relocate1 (objfile
, new_offsets
);
873 for (debug_objfile
= objfile
->separate_debug_objfile
;
875 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
877 struct section_addr_info
*objfile_addrs
;
878 struct section_offsets
*new_debug_offsets
;
879 struct cleanup
*my_cleanups
;
881 objfile_addrs
= build_section_addr_info_from_objfile (objfile
);
882 my_cleanups
= make_cleanup (xfree
, objfile_addrs
);
884 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
885 relative ones must be already created according to debug_objfile. */
887 addr_info_make_relative (objfile_addrs
, debug_objfile
->obfd
);
889 gdb_assert (debug_objfile
->num_sections
890 == gdb_bfd_count_sections (debug_objfile
->obfd
));
892 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile
->num_sections
));
893 make_cleanup (xfree
, new_debug_offsets
);
894 relative_addr_info_to_section_offsets (new_debug_offsets
,
895 debug_objfile
->num_sections
,
898 changed
|= objfile_relocate1 (debug_objfile
, new_debug_offsets
);
900 do_cleanups (my_cleanups
);
903 /* Relocate breakpoints as necessary, after things are relocated. */
905 breakpoint_re_set ();
908 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
910 Return non-zero iff any change happened. */
913 objfile_rebase1 (struct objfile
*objfile
, CORE_ADDR slide
)
915 struct section_offsets
*new_offsets
=
916 ((struct section_offsets
*)
917 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
920 for (i
= 0; i
< objfile
->num_sections
; ++i
)
921 new_offsets
->offsets
[i
] = slide
;
923 return objfile_relocate1 (objfile
, new_offsets
);
926 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
927 SEPARATE_DEBUG_OBJFILEs. */
930 objfile_rebase (struct objfile
*objfile
, CORE_ADDR slide
)
932 struct objfile
*debug_objfile
;
935 changed
|= objfile_rebase1 (objfile
, slide
);
937 for (debug_objfile
= objfile
->separate_debug_objfile
;
939 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
940 changed
|= objfile_rebase1 (debug_objfile
, slide
);
942 /* Relocate breakpoints as necessary, after things are relocated. */
944 breakpoint_re_set ();
947 /* Return non-zero if OBJFILE has partial symbols. */
950 objfile_has_partial_symbols (struct objfile
*objfile
)
955 /* If we have not read psymbols, but we have a function capable of reading
956 them, then that is an indication that they are in fact available. Without
957 this function the symbols may have been already read in but they also may
958 not be present in this objfile. */
959 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0
960 && objfile
->sf
->sym_read_psymbols
!= NULL
)
963 return objfile
->sf
->qf
->has_symbols (objfile
);
966 /* Return non-zero if OBJFILE has full symbols. */
969 objfile_has_full_symbols (struct objfile
*objfile
)
971 return objfile
->symtabs
!= NULL
;
974 /* Return non-zero if OBJFILE has full or partial symbols, either directly
975 or through a separate debug file. */
978 objfile_has_symbols (struct objfile
*objfile
)
982 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
983 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
989 /* Many places in gdb want to test just to see if we have any partial
990 symbols available. This function returns zero if none are currently
991 available, nonzero otherwise. */
994 have_partial_symbols (void)
1000 if (objfile_has_partial_symbols (ofp
))
1006 /* Many places in gdb want to test just to see if we have any full
1007 symbols available. This function returns zero if none are currently
1008 available, nonzero otherwise. */
1011 have_full_symbols (void)
1013 struct objfile
*ofp
;
1017 if (objfile_has_full_symbols (ofp
))
1024 /* This operations deletes all objfile entries that represent solibs that
1025 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1029 objfile_purge_solibs (void)
1031 struct objfile
*objf
;
1032 struct objfile
*temp
;
1034 ALL_OBJFILES_SAFE (objf
, temp
)
1036 /* We assume that the solib package has been purged already, or will
1039 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
1040 free_objfile (objf
);
1045 /* Many places in gdb want to test just to see if we have any minimal
1046 symbols available. This function returns zero if none are currently
1047 available, nonzero otherwise. */
1050 have_minimal_symbols (void)
1052 struct objfile
*ofp
;
1056 if (ofp
->minimal_symbol_count
> 0)
1064 /* Qsort comparison function. */
1067 qsort_cmp (const void *a
, const void *b
)
1069 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
1070 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
1071 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1072 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1074 if (sect1_addr
< sect2_addr
)
1076 else if (sect1_addr
> sect2_addr
)
1080 /* Sections are at the same address. This could happen if
1081 A) we have an objfile and a separate debuginfo.
1082 B) we are confused, and have added sections without proper relocation,
1083 or something like that. */
1085 const struct objfile
*const objfile1
= sect1
->objfile
;
1086 const struct objfile
*const objfile2
= sect2
->objfile
;
1088 if (objfile1
->separate_debug_objfile
== objfile2
1089 || objfile2
->separate_debug_objfile
== objfile1
)
1091 /* Case A. The ordering doesn't matter: separate debuginfo files
1092 will be filtered out later. */
1097 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1098 triage. This section could be slow (since we iterate over all
1099 objfiles in each call to qsort_cmp), but this shouldn't happen
1100 very often (GDB is already in a confused state; one hopes this
1101 doesn't happen at all). If you discover that significant time is
1102 spent in the loops below, do 'set complaints 100' and examine the
1103 resulting complaints. */
1105 if (objfile1
== objfile2
)
1107 /* Both sections came from the same objfile. We are really confused.
1108 Sort on sequence order of sections within the objfile. */
1110 const struct obj_section
*osect
;
1112 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1115 else if (osect
== sect2
)
1118 /* We should have found one of the sections before getting here. */
1119 gdb_assert_not_reached ("section not found");
1123 /* Sort on sequence number of the objfile in the chain. */
1125 const struct objfile
*objfile
;
1127 ALL_OBJFILES (objfile
)
1128 if (objfile
== objfile1
)
1130 else if (objfile
== objfile2
)
1133 /* We should have found one of the objfiles before getting here. */
1134 gdb_assert_not_reached ("objfile not found");
1139 gdb_assert_not_reached ("unexpected code path");
1143 /* Select "better" obj_section to keep. We prefer the one that came from
1144 the real object, rather than the one from separate debuginfo.
1145 Most of the time the two sections are exactly identical, but with
1146 prelinking the .rel.dyn section in the real object may have different
1149 static struct obj_section
*
1150 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
1152 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
1153 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
1154 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
1155 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
1156 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
1158 if (a
->objfile
->separate_debug_objfile
!= NULL
)
1163 /* Return 1 if SECTION should be inserted into the section map.
1164 We want to insert only non-overlay and non-TLS section. */
1167 insert_section_p (const struct bfd
*abfd
,
1168 const struct bfd_section
*section
)
1170 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
1172 if (overlay_debugging
&& lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
1173 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
1174 /* This is an overlay section. IN_MEMORY check is needed to avoid
1175 discarding sections from the "system supplied DSO" (aka vdso)
1176 on some Linux systems (e.g. Fedora 11). */
1178 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
1179 /* This is a TLS section. */
1185 /* Filter out overlapping sections where one section came from the real
1186 objfile, and the other from a separate debuginfo file.
1187 Return the size of table after redundant sections have been eliminated. */
1190 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1194 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1196 struct obj_section
*const sect1
= map
[i
];
1197 struct obj_section
*const sect2
= map
[i
+ 1];
1198 const struct objfile
*const objfile1
= sect1
->objfile
;
1199 const struct objfile
*const objfile2
= sect2
->objfile
;
1200 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1201 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1203 if (sect1_addr
== sect2_addr
1204 && (objfile1
->separate_debug_objfile
== objfile2
1205 || objfile2
->separate_debug_objfile
== objfile1
))
1207 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1216 gdb_assert (i
== map_size
- 1);
1220 /* The map should not have shrunk to less than half the original size. */
1221 gdb_assert (map_size
/ 2 <= j
);
1226 /* Filter out overlapping sections, issuing a warning if any are found.
1227 Overlapping sections could really be overlay sections which we didn't
1228 classify as such in insert_section_p, or we could be dealing with a
1232 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1236 for (i
= 0, j
= 0; i
< map_size
- 1; )
1241 for (k
= i
+ 1; k
< map_size
; k
++)
1243 struct obj_section
*const sect1
= map
[i
];
1244 struct obj_section
*const sect2
= map
[k
];
1245 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1246 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1247 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1249 gdb_assert (sect1_addr
<= sect2_addr
);
1251 if (sect1_endaddr
<= sect2_addr
)
1255 /* We have an overlap. Report it. */
1257 struct objfile
*const objf1
= sect1
->objfile
;
1258 struct objfile
*const objf2
= sect2
->objfile
;
1260 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1261 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1263 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1265 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1267 complaint (&symfile_complaints
,
1268 _("unexpected overlap between:\n"
1269 " (A) section `%s' from `%s' [%s, %s)\n"
1270 " (B) section `%s' from `%s' [%s, %s).\n"
1271 "Will ignore section B"),
1272 bfd_section_name (abfd1
, bfds1
), objfile_name (objf1
),
1273 paddress (gdbarch
, sect1_addr
),
1274 paddress (gdbarch
, sect1_endaddr
),
1275 bfd_section_name (abfd2
, bfds2
), objfile_name (objf2
),
1276 paddress (gdbarch
, sect2_addr
),
1277 paddress (gdbarch
, sect2_endaddr
));
1285 gdb_assert (i
== map_size
- 1);
1293 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1294 TLS, overlay and overlapping sections. */
1297 update_section_map (struct program_space
*pspace
,
1298 struct obj_section
***pmap
, int *pmap_size
)
1300 struct objfile_pspace_info
*pspace_info
;
1301 int alloc_size
, map_size
, i
;
1302 struct obj_section
*s
, **map
;
1303 struct objfile
*objfile
;
1305 pspace_info
= get_objfile_pspace_data (pspace
);
1306 gdb_assert (pspace_info
->section_map_dirty
!= 0
1307 || pspace_info
->new_objfiles_available
!= 0);
1313 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1314 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1315 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1318 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1319 if (alloc_size
== 0)
1326 map
= xmalloc (alloc_size
* sizeof (*map
));
1329 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1330 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1331 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1334 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1335 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1336 map_size
= filter_overlapping_sections(map
, map_size
);
1338 if (map_size
< alloc_size
)
1339 /* Some sections were eliminated. Trim excess space. */
1340 map
= xrealloc (map
, map_size
* sizeof (*map
));
1342 gdb_assert (alloc_size
== map_size
);
1345 *pmap_size
= map_size
;
1348 /* Bsearch comparison function. */
1351 bsearch_cmp (const void *key
, const void *elt
)
1353 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1354 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1356 if (pc
< obj_section_addr (section
))
1358 if (pc
< obj_section_endaddr (section
))
1363 /* Returns a section whose range includes PC or NULL if none found. */
1365 struct obj_section
*
1366 find_pc_section (CORE_ADDR pc
)
1368 struct objfile_pspace_info
*pspace_info
;
1369 struct obj_section
*s
, **sp
;
1371 /* Check for mapped overlay section first. */
1372 s
= find_pc_mapped_section (pc
);
1376 pspace_info
= get_objfile_pspace_data (current_program_space
);
1377 if (pspace_info
->section_map_dirty
1378 || (pspace_info
->new_objfiles_available
1379 && !pspace_info
->inhibit_updates
))
1381 update_section_map (current_program_space
,
1382 &pspace_info
->sections
,
1383 &pspace_info
->num_sections
);
1385 /* Don't need updates to section map until objfiles are added,
1386 removed or relocated. */
1387 pspace_info
->new_objfiles_available
= 0;
1388 pspace_info
->section_map_dirty
= 0;
1391 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1392 bsearch be non-NULL. */
1393 if (pspace_info
->sections
== NULL
)
1395 gdb_assert (pspace_info
->num_sections
== 0);
1399 sp
= (struct obj_section
**) bsearch (&pc
,
1400 pspace_info
->sections
,
1401 pspace_info
->num_sections
,
1402 sizeof (*pspace_info
->sections
),
1410 /* Return non-zero if PC is in a section called NAME. */
1413 pc_in_section (CORE_ADDR pc
, char *name
)
1415 struct obj_section
*s
;
1418 s
= find_pc_section (pc
);
1421 && s
->the_bfd_section
->name
!= NULL
1422 && strcmp (s
->the_bfd_section
->name
, name
) == 0);
1427 /* Set section_map_dirty so section map will be rebuilt next time it
1428 is used. Called by reread_symbols. */
1431 objfiles_changed (void)
1433 /* Rebuild section map next time we need it. */
1434 get_objfile_pspace_data (current_program_space
)->section_map_dirty
= 1;
1437 /* See comments in objfiles.h. */
1440 inhibit_section_map_updates (struct program_space
*pspace
)
1442 get_objfile_pspace_data (pspace
)->inhibit_updates
= 1;
1445 /* See comments in objfiles.h. */
1448 resume_section_map_updates (struct program_space
*pspace
)
1450 get_objfile_pspace_data (pspace
)->inhibit_updates
= 0;
1453 /* See comments in objfiles.h. */
1456 resume_section_map_updates_cleanup (void *arg
)
1458 resume_section_map_updates (arg
);
1461 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1465 is_addr_in_objfile (CORE_ADDR addr
, const struct objfile
*objfile
)
1467 struct obj_section
*osect
;
1469 if (objfile
== NULL
)
1472 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1474 if (section_is_overlay (osect
) && !section_is_mapped (osect
))
1477 if (obj_section_addr (osect
) <= addr
1478 && addr
< obj_section_endaddr (osect
))
1484 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1485 gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
1486 searching the objfiles in the order they are stored internally,
1487 ignoring CURRENT_OBJFILE.
1489 On most platorms, it should be close enough to doing the best
1490 we can without some knowledge specific to the architecture. */
1493 default_iterate_over_objfiles_in_search_order
1494 (struct gdbarch
*gdbarch
,
1495 iterate_over_objfiles_in_search_order_cb_ftype
*cb
,
1496 void *cb_data
, struct objfile
*current_objfile
)
1499 struct objfile
*objfile
;
1501 ALL_OBJFILES (objfile
)
1503 stop
= cb (objfile
, cb_data
);
1509 /* Return canonical name for OBJFILE. */
1512 objfile_name (const struct objfile
*objfile
)
1514 if (objfile
->obfd
!= NULL
)
1515 return bfd_get_filename (objfile
->obfd
);
1517 return objfile
->original_name
;
1520 /* Provide a prototype to silence -Wmissing-prototypes. */
1521 extern initialize_file_ftype _initialize_objfiles
;
1524 _initialize_objfiles (void)
1526 objfiles_pspace_data
1527 = register_program_space_data_with_cleanup (NULL
,
1528 objfiles_pspace_data_cleanup
);
1530 objfiles_bfd_data
= register_bfd_data_with_cleanup (NULL
,
1531 objfile_bfd_data_free
);