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
);
140 /* If the object requires gdb to do relocations, we simply fall
141 back to not sharing data across users. These cases are rare
142 enough that this seems reasonable. */
143 if (abfd
!= NULL
&& !gdb_bfd_requires_relocations (abfd
))
145 storage
= bfd_zalloc (abfd
, sizeof (struct objfile_per_bfd_storage
));
146 set_bfd_data (abfd
, objfiles_bfd_data
, storage
);
149 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
150 struct objfile_per_bfd_storage
);
152 /* Look up the gdbarch associated with the BFD. */
154 storage
->gdbarch
= gdbarch_from_bfd (abfd
);
156 obstack_init (&storage
->storage_obstack
);
157 storage
->filename_cache
= bcache_xmalloc (NULL
, NULL
);
158 storage
->macro_cache
= bcache_xmalloc (NULL
, NULL
);
167 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage
*storage
)
169 bcache_xfree (storage
->filename_cache
);
170 bcache_xfree (storage
->macro_cache
);
171 if (storage
->demangled_names_hash
)
172 htab_delete (storage
->demangled_names_hash
);
173 obstack_free (&storage
->storage_obstack
, 0);
176 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
177 cleanup function to the BFD registry. */
180 objfile_bfd_data_free (struct bfd
*unused
, void *d
)
182 free_objfile_per_bfd_storage (d
);
185 /* See objfiles.h. */
188 set_objfile_per_bfd (struct objfile
*objfile
)
190 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, objfile
->obfd
);
195 /* Called via bfd_map_over_sections to build up the section table that
196 the objfile references. The objfile contains pointers to the start
197 of the table (objfile->sections) and to the first location after
198 the end of the table (objfile->sections_end). */
201 add_to_objfile_sections_full (struct bfd
*abfd
, struct bfd_section
*asect
,
202 struct objfile
*objfile
, int force
)
204 struct obj_section
*section
;
210 aflag
= bfd_get_section_flags (abfd
, asect
);
211 if (!(aflag
& SEC_ALLOC
))
215 section
= &objfile
->sections
[gdb_bfd_section_index (abfd
, asect
)];
216 section
->objfile
= objfile
;
217 section
->the_bfd_section
= asect
;
218 section
->ovly_mapped
= 0;
222 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
225 add_to_objfile_sections_full (abfd
, asect
, objfilep
, 0);
228 /* Builds a section table for OBJFILE.
230 Note that the OFFSET and OVLY_MAPPED in each table entry are
231 initialized to zero. */
234 build_objfile_section_table (struct objfile
*objfile
)
236 int count
= gdb_bfd_count_sections (objfile
->obfd
);
238 objfile
->sections
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
241 objfile
->sections_end
= (objfile
->sections
+ count
);
242 bfd_map_over_sections (objfile
->obfd
,
243 add_to_objfile_sections
, (void *) objfile
);
245 /* See gdb_bfd_section_index. */
246 add_to_objfile_sections_full (objfile
->obfd
, bfd_com_section_ptr
, objfile
, 1);
247 add_to_objfile_sections_full (objfile
->obfd
, bfd_und_section_ptr
, objfile
, 1);
248 add_to_objfile_sections_full (objfile
->obfd
, bfd_abs_section_ptr
, objfile
, 1);
249 add_to_objfile_sections_full (objfile
->obfd
, bfd_ind_section_ptr
, objfile
, 1);
252 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
253 allocate a new objfile struct, fill it in as best we can, link it
254 into the list of all known objfiles, and return a pointer to the
257 NAME should contain original non-canonicalized filename or other
258 identifier as entered by user. If there is no better source use
259 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
260 NAME content is copied into returned objfile.
262 The FLAGS word contains various bits (OBJF_*) that can be taken as
263 requests for specific operations. Other bits like OBJF_SHARED are
264 simply copied through to the new objfile flags member. */
266 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
267 by jv-lang.c, to create an artificial objfile used to hold
268 information about dynamically-loaded Java classes. Unfortunately,
269 that branch of this function doesn't get tested very frequently, so
270 it's prone to breakage. (E.g. at one time the name was set to NULL
271 in that situation, which broke a loop over all names in the dynamic
272 library loader.) If you change this function, please try to leave
273 things in a consistent state even if abfd is NULL. */
276 allocate_objfile (bfd
*abfd
, const char *name
, int flags
)
278 struct objfile
*objfile
;
280 objfile
= (struct objfile
*) xzalloc (sizeof (struct objfile
));
281 objfile
->psymbol_cache
= psymbol_bcache_init ();
282 /* We could use obstack_specify_allocation here instead, but
283 gdb_obstack.h specifies the alloc/dealloc functions. */
284 obstack_init (&objfile
->objfile_obstack
);
285 terminate_minimal_symbol_table (objfile
);
287 objfile_alloc_data (objfile
);
291 gdb_assert (abfd
== NULL
);
292 gdb_assert ((flags
& OBJF_NOT_FILENAME
) != 0);
293 name
= "<<anonymous objfile>>";
295 objfile
->original_name
= obstack_copy0 (&objfile
->objfile_obstack
, name
,
298 /* Update the per-objfile information that comes from the bfd, ensuring
299 that any data that is reference is saved in the per-objfile data
302 objfile
->obfd
= abfd
;
306 objfile
->mtime
= bfd_get_mtime (abfd
);
308 /* Build section table. */
309 build_objfile_section_table (objfile
);
312 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, abfd
);
313 objfile
->pspace
= current_program_space
;
315 /* Initialize the section indexes for this objfile, so that we can
316 later detect if they are used w/o being properly assigned to. */
318 objfile
->sect_index_text
= -1;
319 objfile
->sect_index_data
= -1;
320 objfile
->sect_index_bss
= -1;
321 objfile
->sect_index_rodata
= -1;
323 /* Add this file onto the tail of the linked list of other such files. */
325 objfile
->next
= NULL
;
326 if (object_files
== NULL
)
327 object_files
= objfile
;
330 struct objfile
*last_one
;
332 for (last_one
= object_files
;
334 last_one
= last_one
->next
);
335 last_one
->next
= objfile
;
338 /* Save passed in flag bits. */
339 objfile
->flags
|= flags
;
341 /* Rebuild section map next time we need it. */
342 get_objfile_pspace_data (objfile
->pspace
)->new_objfiles_available
= 1;
347 /* Retrieve the gdbarch associated with OBJFILE. */
349 get_objfile_arch (struct objfile
*objfile
)
351 return objfile
->per_bfd
->gdbarch
;
354 /* If there is a valid and known entry point, function fills *ENTRY_P with it
355 and returns non-zero; otherwise it returns zero. */
358 entry_point_address_query (CORE_ADDR
*entry_p
)
360 if (symfile_objfile
== NULL
|| !symfile_objfile
->ei
.entry_point_p
)
363 *entry_p
= symfile_objfile
->ei
.entry_point
;
368 /* Get current entry point address. Call error if it is not known. */
371 entry_point_address (void)
375 if (!entry_point_address_query (&retval
))
376 error (_("Entry point address is not known."));
381 /* Iterator on PARENT and every separate debug objfile of PARENT.
382 The usage pattern is:
383 for (objfile = parent;
385 objfile = objfile_separate_debug_iterate (parent, objfile))
390 objfile_separate_debug_iterate (const struct objfile
*parent
,
391 const struct objfile
*objfile
)
395 /* If any, return the first child. */
396 res
= objfile
->separate_debug_objfile
;
400 /* Common case where there is no separate debug objfile. */
401 if (objfile
== parent
)
404 /* Return the brother if any. Note that we don't iterate on brothers of
406 res
= objfile
->separate_debug_objfile_link
;
410 for (res
= objfile
->separate_debug_objfile_backlink
;
412 res
= res
->separate_debug_objfile_backlink
)
414 gdb_assert (res
!= NULL
);
415 if (res
->separate_debug_objfile_link
)
416 return res
->separate_debug_objfile_link
;
421 /* Put one object file before a specified on in the global list.
422 This can be used to make sure an object file is destroyed before
423 another when using ALL_OBJFILES_SAFE to free all objfiles. */
425 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
427 struct objfile
**objp
;
429 unlink_objfile (objfile
);
431 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
433 if (*objp
== before_this
)
435 objfile
->next
= *objp
;
441 internal_error (__FILE__
, __LINE__
,
442 _("put_objfile_before: before objfile not in list"));
445 /* Put OBJFILE at the front of the list. */
448 objfile_to_front (struct objfile
*objfile
)
450 struct objfile
**objp
;
451 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
453 if (*objp
== objfile
)
455 /* Unhook it from where it is. */
456 *objp
= objfile
->next
;
457 /* Put it in the front. */
458 objfile
->next
= object_files
;
459 object_files
= objfile
;
465 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
468 It is not a bug, or error, to call this function if OBJFILE is not known
469 to be in the current list. This is done in the case of mapped objfiles,
470 for example, just to ensure that the mapped objfile doesn't appear twice
471 in the list. Since the list is threaded, linking in a mapped objfile
472 twice would create a circular list.
474 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
475 unlinking it, just to ensure that we have completely severed any linkages
476 between the OBJFILE and the list. */
479 unlink_objfile (struct objfile
*objfile
)
481 struct objfile
**objpp
;
483 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
485 if (*objpp
== objfile
)
487 *objpp
= (*objpp
)->next
;
488 objfile
->next
= NULL
;
493 internal_error (__FILE__
, __LINE__
,
494 _("unlink_objfile: objfile already unlinked"));
497 /* Add OBJFILE as a separate debug objfile of PARENT. */
500 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
502 gdb_assert (objfile
&& parent
);
504 /* Must not be already in a list. */
505 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
506 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
507 gdb_assert (objfile
->separate_debug_objfile
== NULL
);
508 gdb_assert (parent
->separate_debug_objfile_backlink
== NULL
);
509 gdb_assert (parent
->separate_debug_objfile_link
== NULL
);
511 objfile
->separate_debug_objfile_backlink
= parent
;
512 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
513 parent
->separate_debug_objfile
= objfile
;
515 /* Put the separate debug object before the normal one, this is so that
516 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
517 put_objfile_before (objfile
, parent
);
520 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
524 free_objfile_separate_debug (struct objfile
*objfile
)
526 struct objfile
*child
;
528 for (child
= objfile
->separate_debug_objfile
; child
;)
530 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
531 free_objfile (child
);
536 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
537 that as much as possible is allocated on the objfile_obstack
538 so that the memory can be efficiently freed.
540 Things which we do NOT free because they are not in malloc'd memory
541 or not in memory specific to the objfile include:
545 FIXME: If the objfile is using reusable symbol information (via mmalloc),
546 then we need to take into account the fact that more than one process
547 may be using the symbol information at the same time (when mmalloc is
548 extended to support cooperative locking). When more than one process
549 is using the mapped symbol info, we need to be more careful about when
550 we free objects in the reusable area. */
553 free_objfile (struct objfile
*objfile
)
555 /* Free all separate debug objfiles. */
556 free_objfile_separate_debug (objfile
);
558 if (objfile
->separate_debug_objfile_backlink
)
560 /* We freed the separate debug file, make sure the base objfile
561 doesn't reference it. */
562 struct objfile
*child
;
564 child
= objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
;
566 if (child
== objfile
)
568 /* OBJFILE is the first child. */
569 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
=
570 objfile
->separate_debug_objfile_link
;
574 /* Find OBJFILE in the list. */
577 if (child
->separate_debug_objfile_link
== objfile
)
579 child
->separate_debug_objfile_link
=
580 objfile
->separate_debug_objfile_link
;
583 child
= child
->separate_debug_objfile_link
;
589 /* Remove any references to this objfile in the global value
591 preserve_values (objfile
);
593 /* It still may reference data modules have associated with the objfile and
594 the symbol file data. */
595 forget_cached_source_info_for_objfile (objfile
);
597 breakpoint_free_objfile (objfile
);
598 btrace_free_objfile (objfile
);
600 /* First do any symbol file specific actions required when we are
601 finished with a particular symbol file. Note that if the objfile
602 is using reusable symbol information (via mmalloc) then each of
603 these routines is responsible for doing the correct thing, either
604 freeing things which are valid only during this particular gdb
605 execution, or leaving them to be reused during the next one. */
607 if (objfile
->sf
!= NULL
)
609 (*objfile
->sf
->sym_finish
) (objfile
);
612 /* Discard any data modules have associated with the objfile. The function
613 still may reference objfile->obfd. */
614 objfile_free_data (objfile
);
617 gdb_bfd_unref (objfile
->obfd
);
619 free_objfile_per_bfd_storage (objfile
->per_bfd
);
621 /* Remove it from the chain of all objfiles. */
623 unlink_objfile (objfile
);
625 if (objfile
== symfile_objfile
)
626 symfile_objfile
= NULL
;
628 /* Before the symbol table code was redone to make it easier to
629 selectively load and remove information particular to a specific
630 linkage unit, gdb used to do these things whenever the monolithic
631 symbol table was blown away. How much still needs to be done
632 is unknown, but we play it safe for now and keep each action until
633 it is shown to be no longer needed. */
635 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
636 for example), so we need to call this here. */
637 clear_pc_function_cache ();
639 /* Clear globals which might have pointed into a removed objfile.
640 FIXME: It's not clear which of these are supposed to persist
641 between expressions and which ought to be reset each time. */
642 expression_context_block
= NULL
;
643 innermost_block
= NULL
;
645 /* Check to see if the current_source_symtab belongs to this objfile,
646 and if so, call clear_current_source_symtab_and_line. */
649 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
651 if (cursal
.symtab
&& cursal
.symtab
->objfile
== objfile
)
652 clear_current_source_symtab_and_line ();
655 if (objfile
->global_psymbols
.list
)
656 xfree (objfile
->global_psymbols
.list
);
657 if (objfile
->static_psymbols
.list
)
658 xfree (objfile
->static_psymbols
.list
);
659 /* Free the obstacks for non-reusable objfiles. */
660 psymbol_bcache_free (objfile
->psymbol_cache
);
661 obstack_free (&objfile
->objfile_obstack
, 0);
663 /* Rebuild section map next time we need it. */
664 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
666 /* The last thing we do is free the objfile struct itself. */
671 do_free_objfile_cleanup (void *obj
)
677 make_cleanup_free_objfile (struct objfile
*obj
)
679 return make_cleanup (do_free_objfile_cleanup
, obj
);
682 /* Free all the object files at once and clean up their users. */
685 free_all_objfiles (void)
687 struct objfile
*objfile
, *temp
;
690 /* Any objfile referencewould become stale. */
691 for (so
= master_so_list (); so
; so
= so
->next
)
692 gdb_assert (so
->objfile
== NULL
);
694 ALL_OBJFILES_SAFE (objfile
, temp
)
696 free_objfile (objfile
);
698 clear_symtab_users (0);
701 /* A helper function for objfile_relocate1 that relocates a single
705 relocate_one_symbol (struct symbol
*sym
, struct objfile
*objfile
,
706 struct section_offsets
*delta
)
708 fixup_symbol_section (sym
, objfile
);
710 /* The RS6000 code from which this was taken skipped
711 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
712 But I'm leaving out that test, on the theory that
713 they can't possibly pass the tests below. */
714 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
715 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
716 && SYMBOL_SECTION (sym
) >= 0)
718 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (delta
, SYMBOL_SECTION (sym
));
722 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
723 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
724 Return non-zero iff any change happened. */
727 objfile_relocate1 (struct objfile
*objfile
,
728 const struct section_offsets
*new_offsets
)
730 struct obj_section
*s
;
731 struct section_offsets
*delta
=
732 ((struct section_offsets
*)
733 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
736 int something_changed
= 0;
738 for (i
= 0; i
< objfile
->num_sections
; ++i
)
741 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
742 if (ANOFFSET (delta
, i
) != 0)
743 something_changed
= 1;
745 if (!something_changed
)
748 /* OK, get all the symtabs. */
752 ALL_OBJFILE_SYMTABS (objfile
, s
)
755 struct blockvector
*bv
;
758 /* First the line table. */
762 for (i
= 0; i
< l
->nitems
; ++i
)
763 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
766 /* Don't relocate a shared blockvector more than once. */
770 bv
= BLOCKVECTOR (s
);
771 if (BLOCKVECTOR_MAP (bv
))
772 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
773 ANOFFSET (delta
, s
->block_line_section
));
775 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
779 struct dict_iterator iter
;
781 b
= BLOCKVECTOR_BLOCK (bv
, i
);
782 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
783 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
785 /* We only want to iterate over the local symbols, not any
786 symbols in included symtabs. */
787 ALL_DICT_SYMBOLS (BLOCK_DICT (b
), iter
, sym
)
789 relocate_one_symbol (sym
, objfile
, delta
);
795 /* Relocate isolated symbols. */
799 for (iter
= objfile
->template_symbols
; iter
; iter
= iter
->hash_next
)
800 relocate_one_symbol (iter
, objfile
, delta
);
803 if (objfile
->psymtabs_addrmap
)
804 addrmap_relocate (objfile
->psymtabs_addrmap
,
805 ANOFFSET (delta
, SECT_OFF_TEXT (objfile
)));
808 objfile
->sf
->qf
->relocate (objfile
, new_offsets
, delta
);
811 struct minimal_symbol
*msym
;
813 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
814 if (SYMBOL_SECTION (msym
) >= 0)
815 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
817 /* Relocating different sections by different amounts may cause the symbols
818 to be out of order. */
819 msymbols_sort (objfile
);
821 if (objfile
->ei
.entry_point_p
)
823 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
824 only as a fallback. */
825 struct obj_section
*s
;
826 s
= find_pc_section (objfile
->ei
.entry_point
);
829 int idx
= gdb_bfd_section_index (objfile
->obfd
, s
->the_bfd_section
);
831 objfile
->ei
.entry_point
+= ANOFFSET (delta
, idx
);
834 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
840 for (i
= 0; i
< objfile
->num_sections
; ++i
)
841 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
844 /* Rebuild section map next time we need it. */
845 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
847 /* Update the table in exec_ops, used to read memory. */
848 ALL_OBJFILE_OSECTIONS (objfile
, s
)
850 int idx
= s
- objfile
->sections
;
852 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
853 obj_section_addr (s
));
856 /* Relocating probes. */
857 if (objfile
->sf
&& objfile
->sf
->sym_probe_fns
)
858 objfile
->sf
->sym_probe_fns
->sym_relocate_probe (objfile
,
865 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
866 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
868 The number and ordering of sections does differ between the two objfiles.
869 Only their names match. Also the file offsets will differ (objfile being
870 possibly prelinked but separate_debug_objfile is probably not prelinked) but
871 the in-memory absolute address as specified by NEW_OFFSETS must match both
875 objfile_relocate (struct objfile
*objfile
,
876 const struct section_offsets
*new_offsets
)
878 struct objfile
*debug_objfile
;
881 changed
|= objfile_relocate1 (objfile
, new_offsets
);
883 for (debug_objfile
= objfile
->separate_debug_objfile
;
885 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
887 struct section_addr_info
*objfile_addrs
;
888 struct section_offsets
*new_debug_offsets
;
889 struct cleanup
*my_cleanups
;
891 objfile_addrs
= build_section_addr_info_from_objfile (objfile
);
892 my_cleanups
= make_cleanup (xfree
, objfile_addrs
);
894 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
895 relative ones must be already created according to debug_objfile. */
897 addr_info_make_relative (objfile_addrs
, debug_objfile
->obfd
);
899 gdb_assert (debug_objfile
->num_sections
900 == gdb_bfd_count_sections (debug_objfile
->obfd
));
902 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile
->num_sections
));
903 make_cleanup (xfree
, new_debug_offsets
);
904 relative_addr_info_to_section_offsets (new_debug_offsets
,
905 debug_objfile
->num_sections
,
908 changed
|= objfile_relocate1 (debug_objfile
, new_debug_offsets
);
910 do_cleanups (my_cleanups
);
913 /* Relocate breakpoints as necessary, after things are relocated. */
915 breakpoint_re_set ();
918 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
920 Return non-zero iff any change happened. */
923 objfile_rebase1 (struct objfile
*objfile
, CORE_ADDR slide
)
925 struct section_offsets
*new_offsets
=
926 ((struct section_offsets
*)
927 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
930 for (i
= 0; i
< objfile
->num_sections
; ++i
)
931 new_offsets
->offsets
[i
] = slide
;
933 return objfile_relocate1 (objfile
, new_offsets
);
936 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
937 SEPARATE_DEBUG_OBJFILEs. */
940 objfile_rebase (struct objfile
*objfile
, CORE_ADDR slide
)
942 struct objfile
*debug_objfile
;
945 changed
|= objfile_rebase1 (objfile
, slide
);
947 for (debug_objfile
= objfile
->separate_debug_objfile
;
949 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
950 changed
|= objfile_rebase1 (debug_objfile
, slide
);
952 /* Relocate breakpoints as necessary, after things are relocated. */
954 breakpoint_re_set ();
957 /* Return non-zero if OBJFILE has partial symbols. */
960 objfile_has_partial_symbols (struct objfile
*objfile
)
965 /* If we have not read psymbols, but we have a function capable of reading
966 them, then that is an indication that they are in fact available. Without
967 this function the symbols may have been already read in but they also may
968 not be present in this objfile. */
969 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0
970 && objfile
->sf
->sym_read_psymbols
!= NULL
)
973 return objfile
->sf
->qf
->has_symbols (objfile
);
976 /* Return non-zero if OBJFILE has full symbols. */
979 objfile_has_full_symbols (struct objfile
*objfile
)
981 return objfile
->symtabs
!= NULL
;
984 /* Return non-zero if OBJFILE has full or partial symbols, either directly
985 or through a separate debug file. */
988 objfile_has_symbols (struct objfile
*objfile
)
992 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
993 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
999 /* Many places in gdb want to test just to see if we have any partial
1000 symbols available. This function returns zero if none are currently
1001 available, nonzero otherwise. */
1004 have_partial_symbols (void)
1006 struct objfile
*ofp
;
1010 if (objfile_has_partial_symbols (ofp
))
1016 /* Many places in gdb want to test just to see if we have any full
1017 symbols available. This function returns zero if none are currently
1018 available, nonzero otherwise. */
1021 have_full_symbols (void)
1023 struct objfile
*ofp
;
1027 if (objfile_has_full_symbols (ofp
))
1034 /* This operations deletes all objfile entries that represent solibs that
1035 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1039 objfile_purge_solibs (void)
1041 struct objfile
*objf
;
1042 struct objfile
*temp
;
1044 ALL_OBJFILES_SAFE (objf
, temp
)
1046 /* We assume that the solib package has been purged already, or will
1049 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
1050 free_objfile (objf
);
1055 /* Many places in gdb want to test just to see if we have any minimal
1056 symbols available. This function returns zero if none are currently
1057 available, nonzero otherwise. */
1060 have_minimal_symbols (void)
1062 struct objfile
*ofp
;
1066 if (ofp
->minimal_symbol_count
> 0)
1074 /* Qsort comparison function. */
1077 qsort_cmp (const void *a
, const void *b
)
1079 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
1080 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
1081 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1082 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1084 if (sect1_addr
< sect2_addr
)
1086 else if (sect1_addr
> sect2_addr
)
1090 /* Sections are at the same address. This could happen if
1091 A) we have an objfile and a separate debuginfo.
1092 B) we are confused, and have added sections without proper relocation,
1093 or something like that. */
1095 const struct objfile
*const objfile1
= sect1
->objfile
;
1096 const struct objfile
*const objfile2
= sect2
->objfile
;
1098 if (objfile1
->separate_debug_objfile
== objfile2
1099 || objfile2
->separate_debug_objfile
== objfile1
)
1101 /* Case A. The ordering doesn't matter: separate debuginfo files
1102 will be filtered out later. */
1107 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1108 triage. This section could be slow (since we iterate over all
1109 objfiles in each call to qsort_cmp), but this shouldn't happen
1110 very often (GDB is already in a confused state; one hopes this
1111 doesn't happen at all). If you discover that significant time is
1112 spent in the loops below, do 'set complaints 100' and examine the
1113 resulting complaints. */
1115 if (objfile1
== objfile2
)
1117 /* Both sections came from the same objfile. We are really confused.
1118 Sort on sequence order of sections within the objfile. */
1120 const struct obj_section
*osect
;
1122 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1125 else if (osect
== sect2
)
1128 /* We should have found one of the sections before getting here. */
1129 gdb_assert_not_reached ("section not found");
1133 /* Sort on sequence number of the objfile in the chain. */
1135 const struct objfile
*objfile
;
1137 ALL_OBJFILES (objfile
)
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 (&symfile_complaints
,
1278 _("unexpected overlap between:\n"
1279 " (A) section `%s' from `%s' [%s, %s)\n"
1280 " (B) section `%s' from `%s' [%s, %s).\n"
1281 "Will ignore section B"),
1282 bfd_section_name (abfd1
, bfds1
), objfile_name (objf1
),
1283 paddress (gdbarch
, sect1_addr
),
1284 paddress (gdbarch
, sect1_endaddr
),
1285 bfd_section_name (abfd2
, bfds2
), objfile_name (objf2
),
1286 paddress (gdbarch
, sect2_addr
),
1287 paddress (gdbarch
, sect2_endaddr
));
1295 gdb_assert (i
== map_size
- 1);
1303 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1304 TLS, overlay and overlapping sections. */
1307 update_section_map (struct program_space
*pspace
,
1308 struct obj_section
***pmap
, int *pmap_size
)
1310 struct objfile_pspace_info
*pspace_info
;
1311 int alloc_size
, map_size
, i
;
1312 struct obj_section
*s
, **map
;
1313 struct objfile
*objfile
;
1315 pspace_info
= get_objfile_pspace_data (pspace
);
1316 gdb_assert (pspace_info
->section_map_dirty
!= 0
1317 || pspace_info
->new_objfiles_available
!= 0);
1323 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1324 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1325 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1328 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1329 if (alloc_size
== 0)
1336 map
= xmalloc (alloc_size
* sizeof (*map
));
1339 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1340 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1341 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1344 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1345 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1346 map_size
= filter_overlapping_sections(map
, map_size
);
1348 if (map_size
< alloc_size
)
1349 /* Some sections were eliminated. Trim excess space. */
1350 map
= xrealloc (map
, map_size
* sizeof (*map
));
1352 gdb_assert (alloc_size
== map_size
);
1355 *pmap_size
= map_size
;
1358 /* Bsearch comparison function. */
1361 bsearch_cmp (const void *key
, const void *elt
)
1363 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1364 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1366 if (pc
< obj_section_addr (section
))
1368 if (pc
< obj_section_endaddr (section
))
1373 /* Returns a section whose range includes PC or NULL if none found. */
1375 struct obj_section
*
1376 find_pc_section (CORE_ADDR pc
)
1378 struct objfile_pspace_info
*pspace_info
;
1379 struct obj_section
*s
, **sp
;
1381 /* Check for mapped overlay section first. */
1382 s
= find_pc_mapped_section (pc
);
1386 pspace_info
= get_objfile_pspace_data (current_program_space
);
1387 if (pspace_info
->section_map_dirty
1388 || (pspace_info
->new_objfiles_available
1389 && !pspace_info
->inhibit_updates
))
1391 update_section_map (current_program_space
,
1392 &pspace_info
->sections
,
1393 &pspace_info
->num_sections
);
1395 /* Don't need updates to section map until objfiles are added,
1396 removed or relocated. */
1397 pspace_info
->new_objfiles_available
= 0;
1398 pspace_info
->section_map_dirty
= 0;
1401 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1402 bsearch be non-NULL. */
1403 if (pspace_info
->sections
== NULL
)
1405 gdb_assert (pspace_info
->num_sections
== 0);
1409 sp
= (struct obj_section
**) bsearch (&pc
,
1410 pspace_info
->sections
,
1411 pspace_info
->num_sections
,
1412 sizeof (*pspace_info
->sections
),
1420 /* Return non-zero if PC is in a section called NAME. */
1423 pc_in_section (CORE_ADDR pc
, char *name
)
1425 struct obj_section
*s
;
1428 s
= find_pc_section (pc
);
1431 && s
->the_bfd_section
->name
!= NULL
1432 && strcmp (s
->the_bfd_section
->name
, name
) == 0);
1437 /* Set section_map_dirty so section map will be rebuilt next time it
1438 is used. Called by reread_symbols. */
1441 objfiles_changed (void)
1443 /* Rebuild section map next time we need it. */
1444 get_objfile_pspace_data (current_program_space
)->section_map_dirty
= 1;
1447 /* See comments in objfiles.h. */
1450 inhibit_section_map_updates (struct program_space
*pspace
)
1452 get_objfile_pspace_data (pspace
)->inhibit_updates
= 1;
1455 /* See comments in objfiles.h. */
1458 resume_section_map_updates (struct program_space
*pspace
)
1460 get_objfile_pspace_data (pspace
)->inhibit_updates
= 0;
1463 /* See comments in objfiles.h. */
1466 resume_section_map_updates_cleanup (void *arg
)
1468 resume_section_map_updates (arg
);
1471 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1472 gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
1473 searching the objfiles in the order they are stored internally,
1474 ignoring CURRENT_OBJFILE.
1476 On most platorms, it should be close enough to doing the best
1477 we can without some knowledge specific to the architecture. */
1480 default_iterate_over_objfiles_in_search_order
1481 (struct gdbarch
*gdbarch
,
1482 iterate_over_objfiles_in_search_order_cb_ftype
*cb
,
1483 void *cb_data
, struct objfile
*current_objfile
)
1486 struct objfile
*objfile
;
1488 ALL_OBJFILES (objfile
)
1490 stop
= cb (objfile
, cb_data
);
1496 /* Return canonical name for OBJFILE. */
1499 objfile_name (const struct objfile
*objfile
)
1501 if (objfile
->obfd
!= NULL
)
1502 return bfd_get_filename (objfile
->obfd
);
1504 return objfile
->original_name
;
1507 /* Provide a prototype to silence -Wmissing-prototypes. */
1508 extern initialize_file_ftype _initialize_objfiles
;
1511 _initialize_objfiles (void)
1513 objfiles_pspace_data
1514 = register_program_space_data_with_cleanup (NULL
,
1515 objfiles_pspace_data_cleanup
);
1517 objfiles_bfd_data
= register_bfd_data_with_cleanup (NULL
,
1518 objfile_bfd_data_free
);