1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Support, using pieces from other GDB modules.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 /* This file contains support routines for creating, manipulating, and
23 destroying objfile structures. */
26 #include "bfd.h" /* Binary File Description */
30 #include "gdb-stabs.h"
33 #include "expression.h"
34 #include "parser-defs.h"
36 #include "gdb_assert.h"
37 #include <sys/types.h>
40 #include "gdb_obstack.h"
41 #include "gdb_string.h"
44 #include "breakpoint.h"
46 #include "dictionary.h"
49 #include "arch-utils.h"
52 #include "complaints.h"
58 /* Keep a registry of per-objfile data-pointers required by other GDB
61 DEFINE_REGISTRY (objfile
, REGISTRY_ACCESS_FIELD
)
63 /* Externally visible variables that are owned by this module.
64 See declarations in objfile.h for more info. */
66 struct objfile_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
;
90 info
= program_space_data (pspace
, objfiles_pspace_data
);
93 xfree (info
->sections
);
98 /* Get the current svr4 data. If none is found yet, add it now. This
99 function always returns a valid object. */
101 static struct objfile_pspace_info
*
102 get_objfile_pspace_data (struct program_space
*pspace
)
104 struct objfile_pspace_info
*info
;
106 info
= program_space_data (pspace
, objfiles_pspace_data
);
109 info
= XZALLOC (struct objfile_pspace_info
);
110 set_program_space_data (pspace
, objfiles_pspace_data
, info
);
118 /* Per-BFD data key. */
120 static const struct bfd_data
*objfiles_bfd_data
;
122 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
123 NULL, and it already has a per-BFD storage object, use that.
124 Otherwise, allocate a new per-BFD storage object. If ABFD is not
125 NULL, the object is allocated on the BFD; otherwise it is allocated
126 on OBJFILE's obstack. Note that it is not safe to call this
127 multiple times for a given OBJFILE -- it can only be called when
128 allocating or re-initializing OBJFILE. */
130 static struct objfile_per_bfd_storage
*
131 get_objfile_bfd_data (struct objfile
*objfile
, struct bfd
*abfd
)
133 struct objfile_per_bfd_storage
*storage
= NULL
;
136 storage
= bfd_data (abfd
, objfiles_bfd_data
);
142 storage
= bfd_zalloc (abfd
, sizeof (struct objfile_per_bfd_storage
));
143 set_bfd_data (abfd
, objfiles_bfd_data
, storage
);
145 /* Look up the gdbarch associated with the BFD. */
146 storage
->gdbarch
= gdbarch_from_bfd (abfd
);
149 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
150 struct objfile_per_bfd_storage
);
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 obstack_free (&storage
->storage_obstack
, 0);
170 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
171 cleanup function to the BFD registry. */
174 objfile_bfd_data_free (struct bfd
*unused
, void *d
)
176 free_objfile_per_bfd_storage (d
);
179 /* See objfiles.h. */
182 set_objfile_per_bfd (struct objfile
*objfile
)
184 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, objfile
->obfd
);
189 /* Called via bfd_map_over_sections to build up the section table that
190 the objfile references. The objfile contains pointers to the start
191 of the table (objfile->sections) and to the first location after
192 the end of the table (objfile->sections_end). */
195 add_to_objfile_sections_full (struct bfd
*abfd
, struct bfd_section
*asect
,
196 struct objfile
*objfile
, int force
)
198 struct obj_section
*section
;
204 aflag
= bfd_get_section_flags (abfd
, asect
);
205 if (!(aflag
& SEC_ALLOC
))
209 section
= &objfile
->sections
[gdb_bfd_section_index (abfd
, asect
)];
210 section
->objfile
= objfile
;
211 section
->the_bfd_section
= asect
;
212 section
->ovly_mapped
= 0;
216 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
219 add_to_objfile_sections_full (abfd
, asect
, objfilep
, 0);
222 /* Builds a section table for OBJFILE.
224 Note that the OFFSET and OVLY_MAPPED in each table entry are
225 initialized to zero. */
228 build_objfile_section_table (struct objfile
*objfile
)
230 int count
= gdb_bfd_count_sections (objfile
->obfd
);
232 objfile
->sections
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
235 objfile
->sections_end
= (objfile
->sections
+ count
);
236 bfd_map_over_sections (objfile
->obfd
,
237 add_to_objfile_sections
, (void *) objfile
);
239 /* See gdb_bfd_section_index. */
240 add_to_objfile_sections_full (objfile
->obfd
, bfd_com_section_ptr
, objfile
, 1);
241 add_to_objfile_sections_full (objfile
->obfd
, bfd_und_section_ptr
, objfile
, 1);
242 add_to_objfile_sections_full (objfile
->obfd
, bfd_abs_section_ptr
, objfile
, 1);
243 add_to_objfile_sections_full (objfile
->obfd
, bfd_ind_section_ptr
, objfile
, 1);
246 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
247 allocate a new objfile struct, fill it in as best we can, link it
248 into the list of all known objfiles, and return a pointer to the
251 NAME should contain original non-canonicalized filename or other
252 identifier as entered by user. If there is no better source use
253 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
254 NAME content is copied into returned objfile.
256 The FLAGS word contains various bits (OBJF_*) that can be taken as
257 requests for specific operations. Other bits like OBJF_SHARED are
258 simply copied through to the new objfile flags member. */
260 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
261 by jv-lang.c, to create an artificial objfile used to hold
262 information about dynamically-loaded Java classes. Unfortunately,
263 that branch of this function doesn't get tested very frequently, so
264 it's prone to breakage. (E.g. at one time the name was set to NULL
265 in that situation, which broke a loop over all names in the dynamic
266 library loader.) If you change this function, please try to leave
267 things in a consistent state even if abfd is NULL. */
270 allocate_objfile (bfd
*abfd
, const char *name
, int flags
)
272 struct objfile
*objfile
;
274 objfile
= (struct objfile
*) xzalloc (sizeof (struct objfile
));
275 objfile
->psymbol_cache
= psymbol_bcache_init ();
276 /* We could use obstack_specify_allocation here instead, but
277 gdb_obstack.h specifies the alloc/dealloc functions. */
278 obstack_init (&objfile
->objfile_obstack
);
279 terminate_minimal_symbol_table (objfile
);
281 objfile_alloc_data (objfile
);
285 gdb_assert (abfd
== NULL
);
286 name
= "<<anonymous objfile>>";
288 objfile
->original_name
= obstack_copy0 (&objfile
->objfile_obstack
, name
,
291 /* Update the per-objfile information that comes from the bfd, ensuring
292 that any data that is reference is saved in the per-objfile data
295 objfile
->obfd
= abfd
;
299 objfile
->mtime
= bfd_get_mtime (abfd
);
301 /* Build section table. */
302 build_objfile_section_table (objfile
);
305 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, abfd
);
306 objfile
->pspace
= current_program_space
;
308 /* Initialize the section indexes for this objfile, so that we can
309 later detect if they are used w/o being properly assigned to. */
311 objfile
->sect_index_text
= -1;
312 objfile
->sect_index_data
= -1;
313 objfile
->sect_index_bss
= -1;
314 objfile
->sect_index_rodata
= -1;
316 /* Add this file onto the tail of the linked list of other such files. */
318 objfile
->next
= NULL
;
319 if (object_files
== NULL
)
320 object_files
= objfile
;
323 struct objfile
*last_one
;
325 for (last_one
= object_files
;
327 last_one
= last_one
->next
);
328 last_one
->next
= objfile
;
331 /* Save passed in flag bits. */
332 objfile
->flags
|= flags
;
334 /* Rebuild section map next time we need it. */
335 get_objfile_pspace_data (objfile
->pspace
)->new_objfiles_available
= 1;
340 /* Retrieve the gdbarch associated with OBJFILE. */
342 get_objfile_arch (struct objfile
*objfile
)
344 return objfile
->per_bfd
->gdbarch
;
347 /* If there is a valid and known entry point, function fills *ENTRY_P with it
348 and returns non-zero; otherwise it returns zero. */
351 entry_point_address_query (CORE_ADDR
*entry_p
)
353 if (symfile_objfile
== NULL
|| !symfile_objfile
->ei
.entry_point_p
)
356 *entry_p
= symfile_objfile
->ei
.entry_point
;
361 /* Get current entry point address. Call error if it is not known. */
364 entry_point_address (void)
368 if (!entry_point_address_query (&retval
))
369 error (_("Entry point address is not known."));
374 /* Iterator on PARENT and every separate debug objfile of PARENT.
375 The usage pattern is:
376 for (objfile = parent;
378 objfile = objfile_separate_debug_iterate (parent, objfile))
383 objfile_separate_debug_iterate (const struct objfile
*parent
,
384 const struct objfile
*objfile
)
388 /* If any, return the first child. */
389 res
= objfile
->separate_debug_objfile
;
393 /* Common case where there is no separate debug objfile. */
394 if (objfile
== parent
)
397 /* Return the brother if any. Note that we don't iterate on brothers of
399 res
= objfile
->separate_debug_objfile_link
;
403 for (res
= objfile
->separate_debug_objfile_backlink
;
405 res
= res
->separate_debug_objfile_backlink
)
407 gdb_assert (res
!= NULL
);
408 if (res
->separate_debug_objfile_link
)
409 return res
->separate_debug_objfile_link
;
414 /* Put one object file before a specified on in the global list.
415 This can be used to make sure an object file is destroyed before
416 another when using ALL_OBJFILES_SAFE to free all objfiles. */
418 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
420 struct objfile
**objp
;
422 unlink_objfile (objfile
);
424 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
426 if (*objp
== before_this
)
428 objfile
->next
= *objp
;
434 internal_error (__FILE__
, __LINE__
,
435 _("put_objfile_before: before objfile not in list"));
438 /* Put OBJFILE at the front of the list. */
441 objfile_to_front (struct objfile
*objfile
)
443 struct objfile
**objp
;
444 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
446 if (*objp
== objfile
)
448 /* Unhook it from where it is. */
449 *objp
= objfile
->next
;
450 /* Put it in the front. */
451 objfile
->next
= object_files
;
452 object_files
= objfile
;
458 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
461 It is not a bug, or error, to call this function if OBJFILE is not known
462 to be in the current list. This is done in the case of mapped objfiles,
463 for example, just to ensure that the mapped objfile doesn't appear twice
464 in the list. Since the list is threaded, linking in a mapped objfile
465 twice would create a circular list.
467 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
468 unlinking it, just to ensure that we have completely severed any linkages
469 between the OBJFILE and the list. */
472 unlink_objfile (struct objfile
*objfile
)
474 struct objfile
**objpp
;
476 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
478 if (*objpp
== objfile
)
480 *objpp
= (*objpp
)->next
;
481 objfile
->next
= NULL
;
486 internal_error (__FILE__
, __LINE__
,
487 _("unlink_objfile: objfile already unlinked"));
490 /* Add OBJFILE as a separate debug objfile of PARENT. */
493 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
495 gdb_assert (objfile
&& parent
);
497 /* Must not be already in a list. */
498 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
499 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
500 gdb_assert (objfile
->separate_debug_objfile
== NULL
);
501 gdb_assert (parent
->separate_debug_objfile_backlink
== NULL
);
502 gdb_assert (parent
->separate_debug_objfile_link
== NULL
);
504 objfile
->separate_debug_objfile_backlink
= parent
;
505 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
506 parent
->separate_debug_objfile
= objfile
;
508 /* Put the separate debug object before the normal one, this is so that
509 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
510 put_objfile_before (objfile
, parent
);
513 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
517 free_objfile_separate_debug (struct objfile
*objfile
)
519 struct objfile
*child
;
521 for (child
= objfile
->separate_debug_objfile
; child
;)
523 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
524 free_objfile (child
);
529 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
530 that as much as possible is allocated on the objfile_obstack
531 so that the memory can be efficiently freed.
533 Things which we do NOT free because they are not in malloc'd memory
534 or not in memory specific to the objfile include:
538 FIXME: If the objfile is using reusable symbol information (via mmalloc),
539 then we need to take into account the fact that more than one process
540 may be using the symbol information at the same time (when mmalloc is
541 extended to support cooperative locking). When more than one process
542 is using the mapped symbol info, we need to be more careful about when
543 we free objects in the reusable area. */
546 free_objfile (struct objfile
*objfile
)
548 /* Free all separate debug objfiles. */
549 free_objfile_separate_debug (objfile
);
551 if (objfile
->separate_debug_objfile_backlink
)
553 /* We freed the separate debug file, make sure the base objfile
554 doesn't reference it. */
555 struct objfile
*child
;
557 child
= objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
;
559 if (child
== objfile
)
561 /* OBJFILE is the first child. */
562 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
=
563 objfile
->separate_debug_objfile_link
;
567 /* Find OBJFILE in the list. */
570 if (child
->separate_debug_objfile_link
== objfile
)
572 child
->separate_debug_objfile_link
=
573 objfile
->separate_debug_objfile_link
;
576 child
= child
->separate_debug_objfile_link
;
582 /* Remove any references to this objfile in the global value
584 preserve_values (objfile
);
586 /* It still may reference data modules have associated with the objfile and
587 the symbol file data. */
588 forget_cached_source_info_for_objfile (objfile
);
590 breakpoint_free_objfile (objfile
);
591 btrace_free_objfile (objfile
);
593 /* First do any symbol file specific actions required when we are
594 finished with a particular symbol file. Note that if the objfile
595 is using reusable symbol information (via mmalloc) then each of
596 these routines is responsible for doing the correct thing, either
597 freeing things which are valid only during this particular gdb
598 execution, or leaving them to be reused during the next one. */
600 if (objfile
->sf
!= NULL
)
602 (*objfile
->sf
->sym_finish
) (objfile
);
605 /* Discard any data modules have associated with the objfile. The function
606 still may reference objfile->obfd. */
607 objfile_free_data (objfile
);
610 gdb_bfd_unref (objfile
->obfd
);
612 free_objfile_per_bfd_storage (objfile
->per_bfd
);
614 /* Remove it from the chain of all objfiles. */
616 unlink_objfile (objfile
);
618 if (objfile
== symfile_objfile
)
619 symfile_objfile
= NULL
;
621 /* Before the symbol table code was redone to make it easier to
622 selectively load and remove information particular to a specific
623 linkage unit, gdb used to do these things whenever the monolithic
624 symbol table was blown away. How much still needs to be done
625 is unknown, but we play it safe for now and keep each action until
626 it is shown to be no longer needed. */
628 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
629 for example), so we need to call this here. */
630 clear_pc_function_cache ();
632 /* Clear globals which might have pointed into a removed objfile.
633 FIXME: It's not clear which of these are supposed to persist
634 between expressions and which ought to be reset each time. */
635 expression_context_block
= NULL
;
636 innermost_block
= NULL
;
638 /* Check to see if the current_source_symtab belongs to this objfile,
639 and if so, call clear_current_source_symtab_and_line. */
642 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
644 if (cursal
.symtab
&& cursal
.symtab
->objfile
== objfile
)
645 clear_current_source_symtab_and_line ();
648 if (objfile
->global_psymbols
.list
)
649 xfree (objfile
->global_psymbols
.list
);
650 if (objfile
->static_psymbols
.list
)
651 xfree (objfile
->static_psymbols
.list
);
652 /* Free the obstacks for non-reusable objfiles. */
653 psymbol_bcache_free (objfile
->psymbol_cache
);
654 if (objfile
->demangled_names_hash
)
655 htab_delete (objfile
->demangled_names_hash
);
656 obstack_free (&objfile
->objfile_obstack
, 0);
658 /* Rebuild section map next time we need it. */
659 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
661 /* The last thing we do is free the objfile struct itself. */
666 do_free_objfile_cleanup (void *obj
)
672 make_cleanup_free_objfile (struct objfile
*obj
)
674 return make_cleanup (do_free_objfile_cleanup
, obj
);
677 /* Free all the object files at once and clean up their users. */
680 free_all_objfiles (void)
682 struct objfile
*objfile
, *temp
;
685 /* Any objfile referencewould become stale. */
686 for (so
= master_so_list (); so
; so
= so
->next
)
687 gdb_assert (so
->objfile
== NULL
);
689 ALL_OBJFILES_SAFE (objfile
, temp
)
691 free_objfile (objfile
);
693 clear_symtab_users (0);
696 /* A helper function for objfile_relocate1 that relocates a single
700 relocate_one_symbol (struct symbol
*sym
, struct objfile
*objfile
,
701 struct section_offsets
*delta
)
703 fixup_symbol_section (sym
, objfile
);
705 /* The RS6000 code from which this was taken skipped
706 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
707 But I'm leaving out that test, on the theory that
708 they can't possibly pass the tests below. */
709 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
710 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
711 && SYMBOL_SECTION (sym
) >= 0)
713 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (delta
, SYMBOL_SECTION (sym
));
717 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
718 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
719 Return non-zero iff any change happened. */
722 objfile_relocate1 (struct objfile
*objfile
,
723 const struct section_offsets
*new_offsets
)
725 struct obj_section
*s
;
726 struct section_offsets
*delta
=
727 ((struct section_offsets
*)
728 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
731 int something_changed
= 0;
733 for (i
= 0; i
< objfile
->num_sections
; ++i
)
736 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
737 if (ANOFFSET (delta
, i
) != 0)
738 something_changed
= 1;
740 if (!something_changed
)
743 /* OK, get all the symtabs. */
747 ALL_OBJFILE_SYMTABS (objfile
, s
)
750 struct blockvector
*bv
;
753 /* First the line table. */
757 for (i
= 0; i
< l
->nitems
; ++i
)
758 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
761 /* Don't relocate a shared blockvector more than once. */
765 bv
= BLOCKVECTOR (s
);
766 if (BLOCKVECTOR_MAP (bv
))
767 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
768 ANOFFSET (delta
, s
->block_line_section
));
770 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
774 struct dict_iterator iter
;
776 b
= BLOCKVECTOR_BLOCK (bv
, i
);
777 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
778 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
780 /* We only want to iterate over the local symbols, not any
781 symbols in included symtabs. */
782 ALL_DICT_SYMBOLS (BLOCK_DICT (b
), iter
, sym
)
784 relocate_one_symbol (sym
, objfile
, delta
);
790 /* Relocate isolated symbols. */
794 for (iter
= objfile
->template_symbols
; iter
; iter
= iter
->hash_next
)
795 relocate_one_symbol (iter
, objfile
, delta
);
798 if (objfile
->psymtabs_addrmap
)
799 addrmap_relocate (objfile
->psymtabs_addrmap
,
800 ANOFFSET (delta
, SECT_OFF_TEXT (objfile
)));
803 objfile
->sf
->qf
->relocate (objfile
, new_offsets
, delta
);
806 struct minimal_symbol
*msym
;
808 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
809 if (SYMBOL_SECTION (msym
) >= 0)
810 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
812 /* Relocating different sections by different amounts may cause the symbols
813 to be out of order. */
814 msymbols_sort (objfile
);
816 if (objfile
->ei
.entry_point_p
)
818 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
819 only as a fallback. */
820 struct obj_section
*s
;
821 s
= find_pc_section (objfile
->ei
.entry_point
);
824 int idx
= gdb_bfd_section_index (objfile
->obfd
, s
->the_bfd_section
);
826 objfile
->ei
.entry_point
+= ANOFFSET (delta
, idx
);
829 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
835 for (i
= 0; i
< objfile
->num_sections
; ++i
)
836 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
839 /* Rebuild section map next time we need it. */
840 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
842 /* Update the table in exec_ops, used to read memory. */
843 ALL_OBJFILE_OSECTIONS (objfile
, s
)
845 int idx
= s
- objfile
->sections
;
847 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
848 obj_section_addr (s
));
851 /* Relocating probes. */
852 if (objfile
->sf
&& objfile
->sf
->sym_probe_fns
)
853 objfile
->sf
->sym_probe_fns
->sym_relocate_probe (objfile
,
860 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
861 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
863 The number and ordering of sections does differ between the two objfiles.
864 Only their names match. Also the file offsets will differ (objfile being
865 possibly prelinked but separate_debug_objfile is probably not prelinked) but
866 the in-memory absolute address as specified by NEW_OFFSETS must match both
870 objfile_relocate (struct objfile
*objfile
,
871 const struct section_offsets
*new_offsets
)
873 struct objfile
*debug_objfile
;
876 changed
|= objfile_relocate1 (objfile
, new_offsets
);
878 for (debug_objfile
= objfile
->separate_debug_objfile
;
880 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
882 struct section_addr_info
*objfile_addrs
;
883 struct section_offsets
*new_debug_offsets
;
884 struct cleanup
*my_cleanups
;
886 objfile_addrs
= build_section_addr_info_from_objfile (objfile
);
887 my_cleanups
= make_cleanup (xfree
, objfile_addrs
);
889 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
890 relative ones must be already created according to debug_objfile. */
892 addr_info_make_relative (objfile_addrs
, debug_objfile
->obfd
);
894 gdb_assert (debug_objfile
->num_sections
895 == gdb_bfd_count_sections (debug_objfile
->obfd
));
897 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile
->num_sections
));
898 make_cleanup (xfree
, new_debug_offsets
);
899 relative_addr_info_to_section_offsets (new_debug_offsets
,
900 debug_objfile
->num_sections
,
903 changed
|= objfile_relocate1 (debug_objfile
, new_debug_offsets
);
905 do_cleanups (my_cleanups
);
908 /* Relocate breakpoints as necessary, after things are relocated. */
910 breakpoint_re_set ();
913 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
915 Return non-zero iff any change happened. */
918 objfile_rebase1 (struct objfile
*objfile
, CORE_ADDR slide
)
920 struct section_offsets
*new_offsets
=
921 ((struct section_offsets
*)
922 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
925 for (i
= 0; i
< objfile
->num_sections
; ++i
)
926 new_offsets
->offsets
[i
] = slide
;
928 return objfile_relocate1 (objfile
, new_offsets
);
931 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
932 SEPARATE_DEBUG_OBJFILEs. */
935 objfile_rebase (struct objfile
*objfile
, CORE_ADDR slide
)
937 struct objfile
*debug_objfile
;
940 changed
|= objfile_rebase1 (objfile
, slide
);
942 for (debug_objfile
= objfile
->separate_debug_objfile
;
944 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
945 changed
|= objfile_rebase1 (debug_objfile
, slide
);
947 /* Relocate breakpoints as necessary, after things are relocated. */
949 breakpoint_re_set ();
952 /* Return non-zero if OBJFILE has partial symbols. */
955 objfile_has_partial_symbols (struct objfile
*objfile
)
960 /* If we have not read psymbols, but we have a function capable of reading
961 them, then that is an indication that they are in fact available. Without
962 this function the symbols may have been already read in but they also may
963 not be present in this objfile. */
964 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0
965 && objfile
->sf
->sym_read_psymbols
!= NULL
)
968 return objfile
->sf
->qf
->has_symbols (objfile
);
971 /* Return non-zero if OBJFILE has full symbols. */
974 objfile_has_full_symbols (struct objfile
*objfile
)
976 return objfile
->symtabs
!= NULL
;
979 /* Return non-zero if OBJFILE has full or partial symbols, either directly
980 or through a separate debug file. */
983 objfile_has_symbols (struct objfile
*objfile
)
987 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
988 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
994 /* Many places in gdb want to test just to see if we have any partial
995 symbols available. This function returns zero if none are currently
996 available, nonzero otherwise. */
999 have_partial_symbols (void)
1001 struct objfile
*ofp
;
1005 if (objfile_has_partial_symbols (ofp
))
1011 /* Many places in gdb want to test just to see if we have any full
1012 symbols available. This function returns zero if none are currently
1013 available, nonzero otherwise. */
1016 have_full_symbols (void)
1018 struct objfile
*ofp
;
1022 if (objfile_has_full_symbols (ofp
))
1029 /* This operations deletes all objfile entries that represent solibs that
1030 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1034 objfile_purge_solibs (void)
1036 struct objfile
*objf
;
1037 struct objfile
*temp
;
1039 ALL_OBJFILES_SAFE (objf
, temp
)
1041 /* We assume that the solib package has been purged already, or will
1044 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
1045 free_objfile (objf
);
1050 /* Many places in gdb want to test just to see if we have any minimal
1051 symbols available. This function returns zero if none are currently
1052 available, nonzero otherwise. */
1055 have_minimal_symbols (void)
1057 struct objfile
*ofp
;
1061 if (ofp
->minimal_symbol_count
> 0)
1069 /* Qsort comparison function. */
1072 qsort_cmp (const void *a
, const void *b
)
1074 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
1075 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
1076 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1077 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1079 if (sect1_addr
< sect2_addr
)
1081 else if (sect1_addr
> sect2_addr
)
1085 /* Sections are at the same address. This could happen if
1086 A) we have an objfile and a separate debuginfo.
1087 B) we are confused, and have added sections without proper relocation,
1088 or something like that. */
1090 const struct objfile
*const objfile1
= sect1
->objfile
;
1091 const struct objfile
*const objfile2
= sect2
->objfile
;
1093 if (objfile1
->separate_debug_objfile
== objfile2
1094 || objfile2
->separate_debug_objfile
== objfile1
)
1096 /* Case A. The ordering doesn't matter: separate debuginfo files
1097 will be filtered out later. */
1102 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1103 triage. This section could be slow (since we iterate over all
1104 objfiles in each call to qsort_cmp), but this shouldn't happen
1105 very often (GDB is already in a confused state; one hopes this
1106 doesn't happen at all). If you discover that significant time is
1107 spent in the loops below, do 'set complaints 100' and examine the
1108 resulting complaints. */
1110 if (objfile1
== objfile2
)
1112 /* Both sections came from the same objfile. We are really confused.
1113 Sort on sequence order of sections within the objfile. */
1115 const struct obj_section
*osect
;
1117 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1120 else if (osect
== sect2
)
1123 /* We should have found one of the sections before getting here. */
1124 gdb_assert_not_reached ("section not found");
1128 /* Sort on sequence number of the objfile in the chain. */
1130 const struct objfile
*objfile
;
1132 ALL_OBJFILES (objfile
)
1133 if (objfile
== objfile1
)
1135 else if (objfile
== objfile2
)
1138 /* We should have found one of the objfiles before getting here. */
1139 gdb_assert_not_reached ("objfile not found");
1144 gdb_assert_not_reached ("unexpected code path");
1148 /* Select "better" obj_section to keep. We prefer the one that came from
1149 the real object, rather than the one from separate debuginfo.
1150 Most of the time the two sections are exactly identical, but with
1151 prelinking the .rel.dyn section in the real object may have different
1154 static struct obj_section
*
1155 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
1157 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
1158 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
1159 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
1160 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
1161 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
1163 if (a
->objfile
->separate_debug_objfile
!= NULL
)
1168 /* Return 1 if SECTION should be inserted into the section map.
1169 We want to insert only non-overlay and non-TLS section. */
1172 insert_section_p (const struct bfd
*abfd
,
1173 const struct bfd_section
*section
)
1175 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
1177 if (overlay_debugging
&& lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
1178 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
1179 /* This is an overlay section. IN_MEMORY check is needed to avoid
1180 discarding sections from the "system supplied DSO" (aka vdso)
1181 on some Linux systems (e.g. Fedora 11). */
1183 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
1184 /* This is a TLS section. */
1190 /* Filter out overlapping sections where one section came from the real
1191 objfile, and the other from a separate debuginfo file.
1192 Return the size of table after redundant sections have been eliminated. */
1195 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1199 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1201 struct obj_section
*const sect1
= map
[i
];
1202 struct obj_section
*const sect2
= map
[i
+ 1];
1203 const struct objfile
*const objfile1
= sect1
->objfile
;
1204 const struct objfile
*const objfile2
= sect2
->objfile
;
1205 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1206 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1208 if (sect1_addr
== sect2_addr
1209 && (objfile1
->separate_debug_objfile
== objfile2
1210 || objfile2
->separate_debug_objfile
== objfile1
))
1212 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1221 gdb_assert (i
== map_size
- 1);
1225 /* The map should not have shrunk to less than half the original size. */
1226 gdb_assert (map_size
/ 2 <= j
);
1231 /* Filter out overlapping sections, issuing a warning if any are found.
1232 Overlapping sections could really be overlay sections which we didn't
1233 classify as such in insert_section_p, or we could be dealing with a
1237 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1241 for (i
= 0, j
= 0; i
< map_size
- 1; )
1246 for (k
= i
+ 1; k
< map_size
; k
++)
1248 struct obj_section
*const sect1
= map
[i
];
1249 struct obj_section
*const sect2
= map
[k
];
1250 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1251 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1252 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1254 gdb_assert (sect1_addr
<= sect2_addr
);
1256 if (sect1_endaddr
<= sect2_addr
)
1260 /* We have an overlap. Report it. */
1262 struct objfile
*const objf1
= sect1
->objfile
;
1263 struct objfile
*const objf2
= sect2
->objfile
;
1265 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1266 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1268 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1270 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1272 complaint (&symfile_complaints
,
1273 _("unexpected overlap between:\n"
1274 " (A) section `%s' from `%s' [%s, %s)\n"
1275 " (B) section `%s' from `%s' [%s, %s).\n"
1276 "Will ignore section B"),
1277 bfd_section_name (abfd1
, bfds1
), objfile_name (objf1
),
1278 paddress (gdbarch
, sect1_addr
),
1279 paddress (gdbarch
, sect1_endaddr
),
1280 bfd_section_name (abfd2
, bfds2
), objfile_name (objf2
),
1281 paddress (gdbarch
, sect2_addr
),
1282 paddress (gdbarch
, sect2_endaddr
));
1290 gdb_assert (i
== map_size
- 1);
1298 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1299 TLS, overlay and overlapping sections. */
1302 update_section_map (struct program_space
*pspace
,
1303 struct obj_section
***pmap
, int *pmap_size
)
1305 struct objfile_pspace_info
*pspace_info
;
1306 int alloc_size
, map_size
, i
;
1307 struct obj_section
*s
, **map
;
1308 struct objfile
*objfile
;
1310 pspace_info
= get_objfile_pspace_data (pspace
);
1311 gdb_assert (pspace_info
->section_map_dirty
!= 0
1312 || pspace_info
->new_objfiles_available
!= 0);
1318 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1319 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1320 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1323 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1324 if (alloc_size
== 0)
1331 map
= xmalloc (alloc_size
* sizeof (*map
));
1334 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1335 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1336 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1339 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1340 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1341 map_size
= filter_overlapping_sections(map
, map_size
);
1343 if (map_size
< alloc_size
)
1344 /* Some sections were eliminated. Trim excess space. */
1345 map
= xrealloc (map
, map_size
* sizeof (*map
));
1347 gdb_assert (alloc_size
== map_size
);
1350 *pmap_size
= map_size
;
1353 /* Bsearch comparison function. */
1356 bsearch_cmp (const void *key
, const void *elt
)
1358 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1359 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1361 if (pc
< obj_section_addr (section
))
1363 if (pc
< obj_section_endaddr (section
))
1368 /* Returns a section whose range includes PC or NULL if none found. */
1370 struct obj_section
*
1371 find_pc_section (CORE_ADDR pc
)
1373 struct objfile_pspace_info
*pspace_info
;
1374 struct obj_section
*s
, **sp
;
1376 /* Check for mapped overlay section first. */
1377 s
= find_pc_mapped_section (pc
);
1381 pspace_info
= get_objfile_pspace_data (current_program_space
);
1382 if (pspace_info
->section_map_dirty
1383 || (pspace_info
->new_objfiles_available
1384 && !pspace_info
->inhibit_updates
))
1386 update_section_map (current_program_space
,
1387 &pspace_info
->sections
,
1388 &pspace_info
->num_sections
);
1390 /* Don't need updates to section map until objfiles are added,
1391 removed or relocated. */
1392 pspace_info
->new_objfiles_available
= 0;
1393 pspace_info
->section_map_dirty
= 0;
1396 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1397 bsearch be non-NULL. */
1398 if (pspace_info
->sections
== NULL
)
1400 gdb_assert (pspace_info
->num_sections
== 0);
1404 sp
= (struct obj_section
**) bsearch (&pc
,
1405 pspace_info
->sections
,
1406 pspace_info
->num_sections
,
1407 sizeof (*pspace_info
->sections
),
1415 /* Return non-zero if PC is in a section called NAME. */
1418 pc_in_section (CORE_ADDR pc
, char *name
)
1420 struct obj_section
*s
;
1423 s
= find_pc_section (pc
);
1426 && s
->the_bfd_section
->name
!= NULL
1427 && strcmp (s
->the_bfd_section
->name
, name
) == 0);
1432 /* Set section_map_dirty so section map will be rebuilt next time it
1433 is used. Called by reread_symbols. */
1436 objfiles_changed (void)
1438 /* Rebuild section map next time we need it. */
1439 get_objfile_pspace_data (current_program_space
)->section_map_dirty
= 1;
1442 /* See comments in objfiles.h. */
1445 inhibit_section_map_updates (struct program_space
*pspace
)
1447 get_objfile_pspace_data (pspace
)->inhibit_updates
= 1;
1450 /* See comments in objfiles.h. */
1453 resume_section_map_updates (struct program_space
*pspace
)
1455 get_objfile_pspace_data (pspace
)->inhibit_updates
= 0;
1458 /* See comments in objfiles.h. */
1461 resume_section_map_updates_cleanup (void *arg
)
1463 resume_section_map_updates (arg
);
1466 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1467 gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
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
)
1481 struct objfile
*objfile
;
1483 ALL_OBJFILES (objfile
)
1485 stop
= cb (objfile
, cb_data
);
1491 /* Return canonical name for OBJFILE. */
1494 objfile_name (const struct objfile
*objfile
)
1496 if (objfile
->obfd
!= NULL
)
1497 return bfd_get_filename (objfile
->obfd
);
1499 return objfile
->original_name
;
1502 /* Provide a prototype to silence -Wmissing-prototypes. */
1503 extern initialize_file_ftype _initialize_objfiles
;
1506 _initialize_objfiles (void)
1508 objfiles_pspace_data
1509 = register_program_space_data_with_cleanup (NULL
,
1510 objfiles_pspace_data_cleanup
);
1512 objfiles_bfd_data
= register_bfd_data_with_cleanup (NULL
,
1513 objfile_bfd_data_free
);