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
*rt_common_objfile
; /* For runtime common symbols */
68 struct objfile_pspace_info
70 int objfiles_changed_p
;
71 struct obj_section
**sections
;
75 /* Per-program-space data key. */
76 static const struct program_space_data
*objfiles_pspace_data
;
79 objfiles_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
81 struct objfile_pspace_info
*info
;
83 info
= program_space_data (pspace
, objfiles_pspace_data
);
86 xfree (info
->sections
);
91 /* Get the current svr4 data. If none is found yet, add it now. This
92 function always returns a valid object. */
94 static struct objfile_pspace_info
*
95 get_objfile_pspace_data (struct program_space
*pspace
)
97 struct objfile_pspace_info
*info
;
99 info
= program_space_data (pspace
, objfiles_pspace_data
);
102 info
= XZALLOC (struct objfile_pspace_info
);
103 set_program_space_data (pspace
, objfiles_pspace_data
, info
);
111 /* Per-BFD data key. */
113 static const struct bfd_data
*objfiles_bfd_data
;
115 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
116 NULL, and it already has a per-BFD storage object, use that.
117 Otherwise, allocate a new per-BFD storage object. If ABFD is not
118 NULL, the object is allocated on the BFD; otherwise it is allocated
119 on OBJFILE's obstack. Note that it is not safe to call this
120 multiple times for a given OBJFILE -- it can only be called when
121 allocating or re-initializing OBJFILE. */
123 static struct objfile_per_bfd_storage
*
124 get_objfile_bfd_data (struct objfile
*objfile
, struct bfd
*abfd
)
126 struct objfile_per_bfd_storage
*storage
= NULL
;
129 storage
= bfd_data (abfd
, objfiles_bfd_data
);
135 storage
= bfd_zalloc (abfd
, sizeof (struct objfile_per_bfd_storage
));
136 set_bfd_data (abfd
, objfiles_bfd_data
, storage
);
139 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
140 struct objfile_per_bfd_storage
);
142 obstack_init (&storage
->storage_obstack
);
143 storage
->filename_cache
= bcache_xmalloc (NULL
, NULL
);
144 storage
->macro_cache
= bcache_xmalloc (NULL
, NULL
);
153 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage
*storage
)
155 bcache_xfree (storage
->filename_cache
);
156 bcache_xfree (storage
->macro_cache
);
157 obstack_free (&storage
->storage_obstack
, 0);
160 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
161 cleanup function to the BFD registry. */
164 objfile_bfd_data_free (struct bfd
*unused
, void *d
)
166 free_objfile_per_bfd_storage (d
);
169 /* See objfiles.h. */
172 set_objfile_per_bfd (struct objfile
*objfile
)
174 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, objfile
->obfd
);
179 /* Called via bfd_map_over_sections to build up the section table that
180 the objfile references. The objfile contains pointers to the start
181 of the table (objfile->sections) and to the first location after
182 the end of the table (objfile->sections_end). */
185 add_to_objfile_sections_full (struct bfd
*abfd
, struct bfd_section
*asect
,
186 struct objfile
*objfile
, int force
)
188 struct obj_section
*section
;
194 aflag
= bfd_get_section_flags (abfd
, asect
);
195 if (!(aflag
& SEC_ALLOC
))
199 section
= &objfile
->sections
[gdb_bfd_section_index (abfd
, asect
)];
200 section
->objfile
= objfile
;
201 section
->the_bfd_section
= asect
;
202 section
->ovly_mapped
= 0;
206 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
209 add_to_objfile_sections_full (abfd
, asect
, objfilep
, 0);
212 /* Builds a section table for OBJFILE.
214 Note that the OFFSET and OVLY_MAPPED in each table entry are
215 initialized to zero. */
218 build_objfile_section_table (struct objfile
*objfile
)
220 int count
= gdb_bfd_count_sections (objfile
->obfd
);
222 objfile
->sections
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
225 objfile
->sections_end
= (objfile
->sections
+ count
);
226 bfd_map_over_sections (objfile
->obfd
,
227 add_to_objfile_sections
, (void *) objfile
);
229 /* See gdb_bfd_section_index. */
230 add_to_objfile_sections_full (objfile
->obfd
, bfd_com_section_ptr
, objfile
, 1);
231 add_to_objfile_sections_full (objfile
->obfd
, bfd_und_section_ptr
, objfile
, 1);
232 add_to_objfile_sections_full (objfile
->obfd
, bfd_abs_section_ptr
, objfile
, 1);
233 add_to_objfile_sections_full (objfile
->obfd
, bfd_ind_section_ptr
, objfile
, 1);
236 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
237 allocate a new objfile struct, fill it in as best we can, link it
238 into the list of all known objfiles, and return a pointer to the
241 The FLAGS word contains various bits (OBJF_*) that can be taken as
242 requests for specific operations. Other bits like OBJF_SHARED are
243 simply copied through to the new objfile flags member. */
245 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
246 by jv-lang.c, to create an artificial objfile used to hold
247 information about dynamically-loaded Java classes. Unfortunately,
248 that branch of this function doesn't get tested very frequently, so
249 it's prone to breakage. (E.g. at one time the name was set to NULL
250 in that situation, which broke a loop over all names in the dynamic
251 library loader.) If you change this function, please try to leave
252 things in a consistent state even if abfd is NULL. */
255 allocate_objfile (bfd
*abfd
, int flags
)
257 struct objfile
*objfile
;
259 objfile
= (struct objfile
*) xzalloc (sizeof (struct objfile
));
260 objfile
->psymbol_cache
= psymbol_bcache_init ();
261 /* We could use obstack_specify_allocation here instead, but
262 gdb_obstack.h specifies the alloc/dealloc functions. */
263 obstack_init (&objfile
->objfile_obstack
);
264 terminate_minimal_symbol_table (objfile
);
266 objfile_alloc_data (objfile
);
268 /* Update the per-objfile information that comes from the bfd, ensuring
269 that any data that is reference is saved in the per-objfile data
272 objfile
->obfd
= abfd
;
276 /* Look up the gdbarch associated with the BFD. */
277 objfile
->gdbarch
= gdbarch_from_bfd (abfd
);
279 objfile
->name
= bfd_get_filename (abfd
);
280 objfile
->mtime
= bfd_get_mtime (abfd
);
282 /* Build section table. */
283 build_objfile_section_table (objfile
);
287 objfile
->name
= "<<anonymous objfile>>";
290 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, abfd
);
291 objfile
->pspace
= current_program_space
;
293 /* Initialize the section indexes for this objfile, so that we can
294 later detect if they are used w/o being properly assigned to. */
296 objfile
->sect_index_text
= -1;
297 objfile
->sect_index_data
= -1;
298 objfile
->sect_index_bss
= -1;
299 objfile
->sect_index_rodata
= -1;
301 /* Add this file onto the tail of the linked list of other such files. */
303 objfile
->next
= NULL
;
304 if (object_files
== NULL
)
305 object_files
= objfile
;
308 struct objfile
*last_one
;
310 for (last_one
= object_files
;
312 last_one
= last_one
->next
);
313 last_one
->next
= objfile
;
316 /* Save passed in flag bits. */
317 objfile
->flags
|= flags
;
319 /* Rebuild section map next time we need it. */
320 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
325 /* Retrieve the gdbarch associated with OBJFILE. */
327 get_objfile_arch (struct objfile
*objfile
)
329 return objfile
->gdbarch
;
332 /* If there is a valid and known entry point, function fills *ENTRY_P with it
333 and returns non-zero; otherwise it returns zero. */
336 entry_point_address_query (CORE_ADDR
*entry_p
)
338 if (symfile_objfile
== NULL
|| !symfile_objfile
->ei
.entry_point_p
)
341 *entry_p
= symfile_objfile
->ei
.entry_point
;
346 /* Get current entry point address. Call error if it is not known. */
349 entry_point_address (void)
353 if (!entry_point_address_query (&retval
))
354 error (_("Entry point address is not known."));
359 /* Iterator on PARENT and every separate debug objfile of PARENT.
360 The usage pattern is:
361 for (objfile = parent;
363 objfile = objfile_separate_debug_iterate (parent, objfile))
368 objfile_separate_debug_iterate (const struct objfile
*parent
,
369 const struct objfile
*objfile
)
373 /* If any, return the first child. */
374 res
= objfile
->separate_debug_objfile
;
378 /* Common case where there is no separate debug objfile. */
379 if (objfile
== parent
)
382 /* Return the brother if any. Note that we don't iterate on brothers of
384 res
= objfile
->separate_debug_objfile_link
;
388 for (res
= objfile
->separate_debug_objfile_backlink
;
390 res
= res
->separate_debug_objfile_backlink
)
392 gdb_assert (res
!= NULL
);
393 if (res
->separate_debug_objfile_link
)
394 return res
->separate_debug_objfile_link
;
399 /* Put one object file before a specified on in the global list.
400 This can be used to make sure an object file is destroyed before
401 another when using ALL_OBJFILES_SAFE to free all objfiles. */
403 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
405 struct objfile
**objp
;
407 unlink_objfile (objfile
);
409 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
411 if (*objp
== before_this
)
413 objfile
->next
= *objp
;
419 internal_error (__FILE__
, __LINE__
,
420 _("put_objfile_before: before objfile not in list"));
423 /* Put OBJFILE at the front of the list. */
426 objfile_to_front (struct objfile
*objfile
)
428 struct objfile
**objp
;
429 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
431 if (*objp
== objfile
)
433 /* Unhook it from where it is. */
434 *objp
= objfile
->next
;
435 /* Put it in the front. */
436 objfile
->next
= object_files
;
437 object_files
= objfile
;
443 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
446 It is not a bug, or error, to call this function if OBJFILE is not known
447 to be in the current list. This is done in the case of mapped objfiles,
448 for example, just to ensure that the mapped objfile doesn't appear twice
449 in the list. Since the list is threaded, linking in a mapped objfile
450 twice would create a circular list.
452 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
453 unlinking it, just to ensure that we have completely severed any linkages
454 between the OBJFILE and the list. */
457 unlink_objfile (struct objfile
*objfile
)
459 struct objfile
**objpp
;
461 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
463 if (*objpp
== objfile
)
465 *objpp
= (*objpp
)->next
;
466 objfile
->next
= NULL
;
471 internal_error (__FILE__
, __LINE__
,
472 _("unlink_objfile: objfile already unlinked"));
475 /* Add OBJFILE as a separate debug objfile of PARENT. */
478 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
480 gdb_assert (objfile
&& parent
);
482 /* Must not be already in a list. */
483 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
484 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
485 gdb_assert (objfile
->separate_debug_objfile
== NULL
);
486 gdb_assert (parent
->separate_debug_objfile_backlink
== NULL
);
487 gdb_assert (parent
->separate_debug_objfile_link
== NULL
);
489 objfile
->separate_debug_objfile_backlink
= parent
;
490 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
491 parent
->separate_debug_objfile
= objfile
;
493 /* Put the separate debug object before the normal one, this is so that
494 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
495 put_objfile_before (objfile
, parent
);
498 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
502 free_objfile_separate_debug (struct objfile
*objfile
)
504 struct objfile
*child
;
506 for (child
= objfile
->separate_debug_objfile
; child
;)
508 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
509 free_objfile (child
);
514 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
515 that as much as possible is allocated on the objfile_obstack
516 so that the memory can be efficiently freed.
518 Things which we do NOT free because they are not in malloc'd memory
519 or not in memory specific to the objfile include:
523 FIXME: If the objfile is using reusable symbol information (via mmalloc),
524 then we need to take into account the fact that more than one process
525 may be using the symbol information at the same time (when mmalloc is
526 extended to support cooperative locking). When more than one process
527 is using the mapped symbol info, we need to be more careful about when
528 we free objects in the reusable area. */
531 free_objfile (struct objfile
*objfile
)
533 /* Free all separate debug objfiles. */
534 free_objfile_separate_debug (objfile
);
536 if (objfile
->separate_debug_objfile_backlink
)
538 /* We freed the separate debug file, make sure the base objfile
539 doesn't reference it. */
540 struct objfile
*child
;
542 child
= objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
;
544 if (child
== objfile
)
546 /* OBJFILE is the first child. */
547 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
=
548 objfile
->separate_debug_objfile_link
;
552 /* Find OBJFILE in the list. */
555 if (child
->separate_debug_objfile_link
== objfile
)
557 child
->separate_debug_objfile_link
=
558 objfile
->separate_debug_objfile_link
;
561 child
= child
->separate_debug_objfile_link
;
567 /* Remove any references to this objfile in the global value
569 preserve_values (objfile
);
571 /* It still may reference data modules have associated with the objfile and
572 the symbol file data. */
573 forget_cached_source_info_for_objfile (objfile
);
575 breakpoint_free_objfile (objfile
);
576 btrace_free_objfile (objfile
);
578 /* First do any symbol file specific actions required when we are
579 finished with a particular symbol file. Note that if the objfile
580 is using reusable symbol information (via mmalloc) then each of
581 these routines is responsible for doing the correct thing, either
582 freeing things which are valid only during this particular gdb
583 execution, or leaving them to be reused during the next one. */
585 if (objfile
->sf
!= NULL
)
587 (*objfile
->sf
->sym_finish
) (objfile
);
590 /* Discard any data modules have associated with the objfile. The function
591 still may reference objfile->obfd. */
592 objfile_free_data (objfile
);
595 gdb_bfd_unref (objfile
->obfd
);
597 free_objfile_per_bfd_storage (objfile
->per_bfd
);
599 /* Remove it from the chain of all objfiles. */
601 unlink_objfile (objfile
);
603 if (objfile
== symfile_objfile
)
604 symfile_objfile
= NULL
;
606 if (objfile
== rt_common_objfile
)
607 rt_common_objfile
= NULL
;
609 /* Before the symbol table code was redone to make it easier to
610 selectively load and remove information particular to a specific
611 linkage unit, gdb used to do these things whenever the monolithic
612 symbol table was blown away. How much still needs to be done
613 is unknown, but we play it safe for now and keep each action until
614 it is shown to be no longer needed. */
616 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
617 for example), so we need to call this here. */
618 clear_pc_function_cache ();
620 /* Clear globals which might have pointed into a removed objfile.
621 FIXME: It's not clear which of these are supposed to persist
622 between expressions and which ought to be reset each time. */
623 expression_context_block
= NULL
;
624 innermost_block
= NULL
;
626 /* Check to see if the current_source_symtab belongs to this objfile,
627 and if so, call clear_current_source_symtab_and_line. */
630 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
632 if (cursal
.symtab
&& cursal
.symtab
->objfile
== objfile
)
633 clear_current_source_symtab_and_line ();
636 /* The last thing we do is free the objfile struct itself. */
638 if (objfile
->global_psymbols
.list
)
639 xfree (objfile
->global_psymbols
.list
);
640 if (objfile
->static_psymbols
.list
)
641 xfree (objfile
->static_psymbols
.list
);
642 /* Free the obstacks for non-reusable objfiles. */
643 psymbol_bcache_free (objfile
->psymbol_cache
);
644 if (objfile
->demangled_names_hash
)
645 htab_delete (objfile
->demangled_names_hash
);
646 obstack_free (&objfile
->objfile_obstack
, 0);
648 /* Rebuild section map next time we need it. */
649 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
655 do_free_objfile_cleanup (void *obj
)
661 make_cleanup_free_objfile (struct objfile
*obj
)
663 return make_cleanup (do_free_objfile_cleanup
, obj
);
666 /* Free all the object files at once and clean up their users. */
669 free_all_objfiles (void)
671 struct objfile
*objfile
, *temp
;
674 /* Any objfile referencewould become stale. */
675 for (so
= master_so_list (); so
; so
= so
->next
)
676 gdb_assert (so
->objfile
== NULL
);
678 ALL_OBJFILES_SAFE (objfile
, temp
)
680 free_objfile (objfile
);
682 clear_symtab_users (0);
685 /* A helper function for objfile_relocate1 that relocates a single
689 relocate_one_symbol (struct symbol
*sym
, struct objfile
*objfile
,
690 struct section_offsets
*delta
)
692 fixup_symbol_section (sym
, objfile
);
694 /* The RS6000 code from which this was taken skipped
695 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
696 But I'm leaving out that test, on the theory that
697 they can't possibly pass the tests below. */
698 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
699 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
700 && SYMBOL_SECTION (sym
) >= 0)
702 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (delta
, SYMBOL_SECTION (sym
));
706 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
707 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
708 Return non-zero iff any change happened. */
711 objfile_relocate1 (struct objfile
*objfile
,
712 struct section_offsets
*new_offsets
)
714 struct obj_section
*s
;
715 struct section_offsets
*delta
=
716 ((struct section_offsets
*)
717 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
720 int something_changed
= 0;
722 for (i
= 0; i
< objfile
->num_sections
; ++i
)
725 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
726 if (ANOFFSET (delta
, i
) != 0)
727 something_changed
= 1;
729 if (!something_changed
)
732 /* OK, get all the symtabs. */
736 ALL_OBJFILE_SYMTABS (objfile
, s
)
739 struct blockvector
*bv
;
742 /* First the line table. */
746 for (i
= 0; i
< l
->nitems
; ++i
)
747 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
750 /* Don't relocate a shared blockvector more than once. */
754 bv
= BLOCKVECTOR (s
);
755 if (BLOCKVECTOR_MAP (bv
))
756 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
757 ANOFFSET (delta
, s
->block_line_section
));
759 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
763 struct dict_iterator iter
;
765 b
= BLOCKVECTOR_BLOCK (bv
, i
);
766 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
767 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
769 /* We only want to iterate over the local symbols, not any
770 symbols in included symtabs. */
771 ALL_DICT_SYMBOLS (BLOCK_DICT (b
), iter
, sym
)
773 relocate_one_symbol (sym
, objfile
, delta
);
779 /* Relocate isolated symbols. */
783 for (iter
= objfile
->template_symbols
; iter
; iter
= iter
->hash_next
)
784 relocate_one_symbol (iter
, objfile
, delta
);
787 if (objfile
->psymtabs_addrmap
)
788 addrmap_relocate (objfile
->psymtabs_addrmap
,
789 ANOFFSET (delta
, SECT_OFF_TEXT (objfile
)));
792 objfile
->sf
->qf
->relocate (objfile
, new_offsets
, delta
);
795 struct minimal_symbol
*msym
;
797 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
798 if (SYMBOL_SECTION (msym
) >= 0)
799 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
801 /* Relocating different sections by different amounts may cause the symbols
802 to be out of order. */
803 msymbols_sort (objfile
);
805 if (objfile
->ei
.entry_point_p
)
807 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
808 only as a fallback. */
809 struct obj_section
*s
;
810 s
= find_pc_section (objfile
->ei
.entry_point
);
813 int idx
= gdb_bfd_section_index (objfile
->obfd
, s
->the_bfd_section
);
815 objfile
->ei
.entry_point
+= ANOFFSET (delta
, idx
);
818 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
824 for (i
= 0; i
< objfile
->num_sections
; ++i
)
825 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
828 /* Rebuild section map next time we need it. */
829 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
831 /* Update the table in exec_ops, used to read memory. */
832 ALL_OBJFILE_OSECTIONS (objfile
, s
)
834 int idx
= s
- objfile
->sections
;
836 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
837 obj_section_addr (s
));
840 /* Relocating probes. */
841 if (objfile
->sf
&& objfile
->sf
->sym_probe_fns
)
842 objfile
->sf
->sym_probe_fns
->sym_relocate_probe (objfile
,
849 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
850 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
852 The number and ordering of sections does differ between the two objfiles.
853 Only their names match. Also the file offsets will differ (objfile being
854 possibly prelinked but separate_debug_objfile is probably not prelinked) but
855 the in-memory absolute address as specified by NEW_OFFSETS must match both
859 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
861 struct objfile
*debug_objfile
;
864 changed
|= objfile_relocate1 (objfile
, new_offsets
);
866 for (debug_objfile
= objfile
->separate_debug_objfile
;
868 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
870 struct section_addr_info
*objfile_addrs
;
871 struct section_offsets
*new_debug_offsets
;
872 struct cleanup
*my_cleanups
;
874 objfile_addrs
= build_section_addr_info_from_objfile (objfile
);
875 my_cleanups
= make_cleanup (xfree
, objfile_addrs
);
877 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
878 relative ones must be already created according to debug_objfile. */
880 addr_info_make_relative (objfile_addrs
, debug_objfile
->obfd
);
882 gdb_assert (debug_objfile
->num_sections
883 == bfd_count_sections (debug_objfile
->obfd
));
885 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile
->num_sections
));
886 make_cleanup (xfree
, new_debug_offsets
);
887 relative_addr_info_to_section_offsets (new_debug_offsets
,
888 debug_objfile
->num_sections
,
891 changed
|= objfile_relocate1 (debug_objfile
, new_debug_offsets
);
893 do_cleanups (my_cleanups
);
896 /* Relocate breakpoints as necessary, after things are relocated. */
898 breakpoint_re_set ();
901 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
903 Return non-zero iff any change happened. */
906 objfile_rebase1 (struct objfile
*objfile
, CORE_ADDR slide
)
908 struct section_offsets
*new_offsets
=
909 ((struct section_offsets
*)
910 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
913 for (i
= 0; i
< objfile
->num_sections
; ++i
)
914 new_offsets
->offsets
[i
] = slide
;
916 return objfile_relocate1 (objfile
, new_offsets
);
919 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
920 SEPARATE_DEBUG_OBJFILEs. */
923 objfile_rebase (struct objfile
*objfile
, CORE_ADDR slide
)
925 struct objfile
*debug_objfile
;
928 changed
|= objfile_rebase1 (objfile
, slide
);
930 for (debug_objfile
= objfile
->separate_debug_objfile
;
932 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
933 changed
|= objfile_rebase1 (debug_objfile
, slide
);
935 /* Relocate breakpoints as necessary, after things are relocated. */
937 breakpoint_re_set ();
940 /* Return non-zero if OBJFILE has partial symbols. */
943 objfile_has_partial_symbols (struct objfile
*objfile
)
948 /* If we have not read psymbols, but we have a function capable of reading
949 them, then that is an indication that they are in fact available. Without
950 this function the symbols may have been already read in but they also may
951 not be present in this objfile. */
952 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0
953 && objfile
->sf
->sym_read_psymbols
!= NULL
)
956 return objfile
->sf
->qf
->has_symbols (objfile
);
959 /* Return non-zero if OBJFILE has full symbols. */
962 objfile_has_full_symbols (struct objfile
*objfile
)
964 return objfile
->symtabs
!= NULL
;
967 /* Return non-zero if OBJFILE has full or partial symbols, either directly
968 or through a separate debug file. */
971 objfile_has_symbols (struct objfile
*objfile
)
975 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
976 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
982 /* Many places in gdb want to test just to see if we have any partial
983 symbols available. This function returns zero if none are currently
984 available, nonzero otherwise. */
987 have_partial_symbols (void)
993 if (objfile_has_partial_symbols (ofp
))
999 /* Many places in gdb want to test just to see if we have any full
1000 symbols available. This function returns zero if none are currently
1001 available, nonzero otherwise. */
1004 have_full_symbols (void)
1006 struct objfile
*ofp
;
1010 if (objfile_has_full_symbols (ofp
))
1017 /* This operations deletes all objfile entries that represent solibs that
1018 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1022 objfile_purge_solibs (void)
1024 struct objfile
*objf
;
1025 struct objfile
*temp
;
1027 ALL_OBJFILES_SAFE (objf
, temp
)
1029 /* We assume that the solib package has been purged already, or will
1032 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
1033 free_objfile (objf
);
1038 /* Many places in gdb want to test just to see if we have any minimal
1039 symbols available. This function returns zero if none are currently
1040 available, nonzero otherwise. */
1043 have_minimal_symbols (void)
1045 struct objfile
*ofp
;
1049 if (ofp
->minimal_symbol_count
> 0)
1057 /* Qsort comparison function. */
1060 qsort_cmp (const void *a
, const void *b
)
1062 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
1063 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
1064 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1065 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1067 if (sect1_addr
< sect2_addr
)
1069 else if (sect1_addr
> sect2_addr
)
1073 /* Sections are at the same address. This could happen if
1074 A) we have an objfile and a separate debuginfo.
1075 B) we are confused, and have added sections without proper relocation,
1076 or something like that. */
1078 const struct objfile
*const objfile1
= sect1
->objfile
;
1079 const struct objfile
*const objfile2
= sect2
->objfile
;
1081 if (objfile1
->separate_debug_objfile
== objfile2
1082 || objfile2
->separate_debug_objfile
== objfile1
)
1084 /* Case A. The ordering doesn't matter: separate debuginfo files
1085 will be filtered out later. */
1090 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1091 triage. This section could be slow (since we iterate over all
1092 objfiles in each call to qsort_cmp), but this shouldn't happen
1093 very often (GDB is already in a confused state; one hopes this
1094 doesn't happen at all). If you discover that significant time is
1095 spent in the loops below, do 'set complaints 100' and examine the
1096 resulting complaints. */
1098 if (objfile1
== objfile2
)
1100 /* Both sections came from the same objfile. We are really confused.
1101 Sort on sequence order of sections within the objfile. */
1103 const struct obj_section
*osect
;
1105 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1108 else if (osect
== sect2
)
1111 /* We should have found one of the sections before getting here. */
1112 gdb_assert_not_reached ("section not found");
1116 /* Sort on sequence number of the objfile in the chain. */
1118 const struct objfile
*objfile
;
1120 ALL_OBJFILES (objfile
)
1121 if (objfile
== objfile1
)
1123 else if (objfile
== objfile2
)
1126 /* We should have found one of the objfiles before getting here. */
1127 gdb_assert_not_reached ("objfile not found");
1132 gdb_assert_not_reached ("unexpected code path");
1136 /* Select "better" obj_section to keep. We prefer the one that came from
1137 the real object, rather than the one from separate debuginfo.
1138 Most of the time the two sections are exactly identical, but with
1139 prelinking the .rel.dyn section in the real object may have different
1142 static struct obj_section
*
1143 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
1145 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
1146 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
1147 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
1148 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
1149 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
1151 if (a
->objfile
->separate_debug_objfile
!= NULL
)
1156 /* Return 1 if SECTION should be inserted into the section map.
1157 We want to insert only non-overlay and non-TLS section. */
1160 insert_section_p (const struct bfd
*abfd
,
1161 const struct bfd_section
*section
)
1163 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
1165 if (overlay_debugging
&& lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
1166 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
1167 /* This is an overlay section. IN_MEMORY check is needed to avoid
1168 discarding sections from the "system supplied DSO" (aka vdso)
1169 on some Linux systems (e.g. Fedora 11). */
1171 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
1172 /* This is a TLS section. */
1178 /* Filter out overlapping sections where one section came from the real
1179 objfile, and the other from a separate debuginfo file.
1180 Return the size of table after redundant sections have been eliminated. */
1183 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1187 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1189 struct obj_section
*const sect1
= map
[i
];
1190 struct obj_section
*const sect2
= map
[i
+ 1];
1191 const struct objfile
*const objfile1
= sect1
->objfile
;
1192 const struct objfile
*const objfile2
= sect2
->objfile
;
1193 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1194 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1196 if (sect1_addr
== sect2_addr
1197 && (objfile1
->separate_debug_objfile
== objfile2
1198 || objfile2
->separate_debug_objfile
== objfile1
))
1200 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1209 gdb_assert (i
== map_size
- 1);
1213 /* The map should not have shrunk to less than half the original size. */
1214 gdb_assert (map_size
/ 2 <= j
);
1219 /* Filter out overlapping sections, issuing a warning if any are found.
1220 Overlapping sections could really be overlay sections which we didn't
1221 classify as such in insert_section_p, or we could be dealing with a
1225 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1229 for (i
= 0, j
= 0; i
< map_size
- 1; )
1234 for (k
= i
+ 1; k
< map_size
; k
++)
1236 struct obj_section
*const sect1
= map
[i
];
1237 struct obj_section
*const sect2
= map
[k
];
1238 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1239 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1240 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1242 gdb_assert (sect1_addr
<= sect2_addr
);
1244 if (sect1_endaddr
<= sect2_addr
)
1248 /* We have an overlap. Report it. */
1250 struct objfile
*const objf1
= sect1
->objfile
;
1251 struct objfile
*const objf2
= sect2
->objfile
;
1253 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1254 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1256 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1258 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1260 complaint (&symfile_complaints
,
1261 _("unexpected overlap between:\n"
1262 " (A) section `%s' from `%s' [%s, %s)\n"
1263 " (B) section `%s' from `%s' [%s, %s).\n"
1264 "Will ignore section B"),
1265 bfd_section_name (abfd1
, bfds1
), objf1
->name
,
1266 paddress (gdbarch
, sect1_addr
),
1267 paddress (gdbarch
, sect1_endaddr
),
1268 bfd_section_name (abfd2
, bfds2
), objf2
->name
,
1269 paddress (gdbarch
, sect2_addr
),
1270 paddress (gdbarch
, sect2_endaddr
));
1278 gdb_assert (i
== map_size
- 1);
1286 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1287 TLS, overlay and overlapping sections. */
1290 update_section_map (struct program_space
*pspace
,
1291 struct obj_section
***pmap
, int *pmap_size
)
1293 int alloc_size
, map_size
, i
;
1294 struct obj_section
*s
, **map
;
1295 struct objfile
*objfile
;
1297 gdb_assert (get_objfile_pspace_data (pspace
)->objfiles_changed_p
!= 0);
1303 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1304 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1305 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1308 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1309 if (alloc_size
== 0)
1316 map
= xmalloc (alloc_size
* sizeof (*map
));
1319 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1320 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1321 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1324 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1325 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1326 map_size
= filter_overlapping_sections(map
, map_size
);
1328 if (map_size
< alloc_size
)
1329 /* Some sections were eliminated. Trim excess space. */
1330 map
= xrealloc (map
, map_size
* sizeof (*map
));
1332 gdb_assert (alloc_size
== map_size
);
1335 *pmap_size
= map_size
;
1338 /* Bsearch comparison function. */
1341 bsearch_cmp (const void *key
, const void *elt
)
1343 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1344 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1346 if (pc
< obj_section_addr (section
))
1348 if (pc
< obj_section_endaddr (section
))
1353 /* Returns a section whose range includes PC or NULL if none found. */
1355 struct obj_section
*
1356 find_pc_section (CORE_ADDR pc
)
1358 struct objfile_pspace_info
*pspace_info
;
1359 struct obj_section
*s
, **sp
;
1361 /* Check for mapped overlay section first. */
1362 s
= find_pc_mapped_section (pc
);
1366 pspace_info
= get_objfile_pspace_data (current_program_space
);
1367 if (pspace_info
->objfiles_changed_p
!= 0)
1369 update_section_map (current_program_space
,
1370 &pspace_info
->sections
,
1371 &pspace_info
->num_sections
);
1373 /* Don't need updates to section map until objfiles are added,
1374 removed or relocated. */
1375 pspace_info
->objfiles_changed_p
= 0;
1378 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1379 bsearch be non-NULL. */
1380 if (pspace_info
->sections
== NULL
)
1382 gdb_assert (pspace_info
->num_sections
== 0);
1386 sp
= (struct obj_section
**) bsearch (&pc
,
1387 pspace_info
->sections
,
1388 pspace_info
->num_sections
,
1389 sizeof (*pspace_info
->sections
),
1397 /* In SVR4, we recognize a trampoline by it's section name.
1398 That is, if the pc is in a section named ".plt" then we are in
1402 in_plt_section (CORE_ADDR pc
, char *name
)
1404 struct obj_section
*s
;
1407 s
= find_pc_section (pc
);
1410 && s
->the_bfd_section
->name
!= NULL
1411 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
1416 /* Set objfiles_changed_p so section map will be rebuilt next time it
1417 is used. Called by reread_symbols. */
1420 objfiles_changed (void)
1422 /* Rebuild section map next time we need it. */
1423 get_objfile_pspace_data (current_program_space
)->objfiles_changed_p
= 1;
1426 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1427 gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
1428 searching the objfiles in the order they are stored internally,
1429 ignoring CURRENT_OBJFILE.
1431 On most platorms, it should be close enough to doing the best
1432 we can without some knowledge specific to the architecture. */
1435 default_iterate_over_objfiles_in_search_order
1436 (struct gdbarch
*gdbarch
,
1437 iterate_over_objfiles_in_search_order_cb_ftype
*cb
,
1438 void *cb_data
, struct objfile
*current_objfile
)
1441 struct objfile
*objfile
;
1443 ALL_OBJFILES (objfile
)
1445 stop
= cb (objfile
, cb_data
);
1451 /* Provide a prototype to silence -Wmissing-prototypes. */
1452 extern initialize_file_ftype _initialize_objfiles
;
1455 _initialize_objfiles (void)
1457 objfiles_pspace_data
1458 = register_program_space_data_with_cleanup (NULL
,
1459 objfiles_pspace_data_cleanup
);
1461 objfiles_bfd_data
= register_bfd_data_with_cleanup (NULL
,
1462 objfile_bfd_data_free
);