1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992-2004, 2007-2012 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 "mdebugread.h"
34 #include "expression.h"
35 #include "parser-defs.h"
37 #include "gdb_assert.h"
38 #include <sys/types.h>
41 #include "gdb_obstack.h"
42 #include "gdb_string.h"
45 #include "breakpoint.h"
47 #include "dictionary.h"
50 #include "arch-utils.h"
53 #include "complaints.h"
58 /* Prototypes for local functions */
60 static void objfile_alloc_data (struct objfile
*objfile
);
61 static void objfile_free_data (struct objfile
*objfile
);
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
);
109 /* Called via bfd_map_over_sections to build up the section table that
110 the objfile references. The objfile contains pointers to the start
111 of the table (objfile->sections) and to the first location after
112 the end of the table (objfile->sections_end). */
115 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
118 struct objfile
*objfile
= (struct objfile
*) objfilep
;
119 struct obj_section section
;
122 aflag
= bfd_get_section_flags (abfd
, asect
);
123 if (!(aflag
& SEC_ALLOC
))
125 if (bfd_section_size (abfd
, asect
) == 0)
128 section
.objfile
= objfile
;
129 section
.the_bfd_section
= asect
;
130 section
.ovly_mapped
= 0;
131 obstack_grow (&objfile
->objfile_obstack
,
132 (char *) §ion
, sizeof (section
));
133 objfile
->sections_end
134 = (struct obj_section
*) (((size_t) objfile
->sections_end
) + 1);
137 /* Builds a section table for OBJFILE.
139 Note that while we are building the table, which goes into the
140 objfile obstack, we hijack the sections_end pointer to instead hold
141 a count of the number of sections. When bfd_map_over_sections
142 returns, this count is used to compute the pointer to the end of
143 the sections table, which then overwrites the count.
145 Also note that the OFFSET and OVLY_MAPPED in each table entry
146 are initialized to zero.
148 Also note that if anything else writes to the objfile obstack while
149 we are building the table, we're pretty much hosed. */
152 build_objfile_section_table (struct objfile
*objfile
)
154 objfile
->sections_end
= 0;
155 bfd_map_over_sections (objfile
->obfd
,
156 add_to_objfile_sections
, (void *) objfile
);
157 objfile
->sections
= obstack_finish (&objfile
->objfile_obstack
);
158 objfile
->sections_end
= objfile
->sections
+ (size_t) objfile
->sections_end
;
161 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
162 allocate a new objfile struct, fill it in as best we can, link it
163 into the list of all known objfiles, and return a pointer to the
166 The FLAGS word contains various bits (OBJF_*) that can be taken as
167 requests for specific operations. Other bits like OBJF_SHARED are
168 simply copied through to the new objfile flags member. */
170 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
171 by jv-lang.c, to create an artificial objfile used to hold
172 information about dynamically-loaded Java classes. Unfortunately,
173 that branch of this function doesn't get tested very frequently, so
174 it's prone to breakage. (E.g. at one time the name was set to NULL
175 in that situation, which broke a loop over all names in the dynamic
176 library loader.) If you change this function, please try to leave
177 things in a consistent state even if abfd is NULL. */
180 allocate_objfile (bfd
*abfd
, int flags
)
182 struct objfile
*objfile
;
184 objfile
= (struct objfile
*) xzalloc (sizeof (struct objfile
));
185 objfile
->psymbol_cache
= psymbol_bcache_init ();
186 objfile
->macro_cache
= bcache_xmalloc (NULL
, NULL
);
187 objfile
->filename_cache
= bcache_xmalloc (NULL
, NULL
);
188 /* We could use obstack_specify_allocation here instead, but
189 gdb_obstack.h specifies the alloc/dealloc functions. */
190 obstack_init (&objfile
->objfile_obstack
);
191 terminate_minimal_symbol_table (objfile
);
193 objfile_alloc_data (objfile
);
195 /* Update the per-objfile information that comes from the bfd, ensuring
196 that any data that is reference is saved in the per-objfile data
199 objfile
->obfd
= abfd
;
203 /* Look up the gdbarch associated with the BFD. */
204 objfile
->gdbarch
= gdbarch_from_bfd (abfd
);
206 objfile
->name
= xstrdup (bfd_get_filename (abfd
));
207 objfile
->mtime
= bfd_get_mtime (abfd
);
209 /* Build section table. */
210 build_objfile_section_table (objfile
);
214 objfile
->name
= xstrdup ("<<anonymous objfile>>");
217 objfile
->pspace
= current_program_space
;
219 /* Initialize the section indexes for this objfile, so that we can
220 later detect if they are used w/o being properly assigned to. */
222 objfile
->sect_index_text
= -1;
223 objfile
->sect_index_data
= -1;
224 objfile
->sect_index_bss
= -1;
225 objfile
->sect_index_rodata
= -1;
227 /* Add this file onto the tail of the linked list of other such files. */
229 objfile
->next
= NULL
;
230 if (object_files
== NULL
)
231 object_files
= objfile
;
234 struct objfile
*last_one
;
236 for (last_one
= object_files
;
238 last_one
= last_one
->next
);
239 last_one
->next
= objfile
;
242 /* Save passed in flag bits. */
243 objfile
->flags
|= flags
;
245 /* Rebuild section map next time we need it. */
246 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
251 /* Retrieve the gdbarch associated with OBJFILE. */
253 get_objfile_arch (struct objfile
*objfile
)
255 return objfile
->gdbarch
;
258 /* Initialize entry point information for this objfile. */
261 init_entry_point_info (struct objfile
*objfile
)
263 /* Save startup file's range of PC addresses to help blockframe.c
264 decide where the bottom of the stack is. */
266 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
268 /* Executable file -- record its entry point so we'll recognize
269 the startup file because it contains the entry point. */
270 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
271 objfile
->ei
.entry_point_p
= 1;
273 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
274 && bfd_get_start_address (objfile
->obfd
) != 0)
276 /* Some shared libraries may have entry points set and be
277 runnable. There's no clear way to indicate this, so just check
278 for values other than zero. */
279 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
280 objfile
->ei
.entry_point_p
= 1;
284 /* Examination of non-executable.o files. Short-circuit this stuff. */
285 objfile
->ei
.entry_point_p
= 0;
289 /* If there is a valid and known entry point, function fills *ENTRY_P with it
290 and returns non-zero; otherwise it returns zero. */
293 entry_point_address_query (CORE_ADDR
*entry_p
)
295 struct gdbarch
*gdbarch
;
296 CORE_ADDR entry_point
;
298 if (symfile_objfile
== NULL
|| !symfile_objfile
->ei
.entry_point_p
)
301 gdbarch
= get_objfile_arch (symfile_objfile
);
303 entry_point
= symfile_objfile
->ei
.entry_point
;
305 /* Make certain that the address points at real code, and not a
306 function descriptor. */
307 entry_point
= gdbarch_convert_from_func_ptr_addr (gdbarch
, entry_point
,
310 /* Remove any ISA markers, so that this matches entries in the
312 entry_point
= gdbarch_addr_bits_remove (gdbarch
, entry_point
);
314 *entry_p
= entry_point
;
318 /* Get current entry point address. Call error if it is not known. */
321 entry_point_address (void)
325 if (!entry_point_address_query (&retval
))
326 error (_("Entry point address is not known."));
331 /* Iterator on PARENT and every separate debug objfile of PARENT.
332 The usage pattern is:
333 for (objfile = parent;
335 objfile = objfile_separate_debug_iterate (parent, objfile))
340 objfile_separate_debug_iterate (const struct objfile
*parent
,
341 const struct objfile
*objfile
)
345 /* If any, return the first child. */
346 res
= objfile
->separate_debug_objfile
;
350 /* Common case where there is no separate debug objfile. */
351 if (objfile
== parent
)
354 /* Return the brother if any. Note that we don't iterate on brothers of
356 res
= objfile
->separate_debug_objfile_link
;
360 for (res
= objfile
->separate_debug_objfile_backlink
;
362 res
= res
->separate_debug_objfile_backlink
)
364 gdb_assert (res
!= NULL
);
365 if (res
->separate_debug_objfile_link
)
366 return res
->separate_debug_objfile_link
;
371 /* Put one object file before a specified on in the global list.
372 This can be used to make sure an object file is destroyed before
373 another when using ALL_OBJFILES_SAFE to free all objfiles. */
375 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
377 struct objfile
**objp
;
379 unlink_objfile (objfile
);
381 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
383 if (*objp
== before_this
)
385 objfile
->next
= *objp
;
391 internal_error (__FILE__
, __LINE__
,
392 _("put_objfile_before: before objfile not in list"));
395 /* Put OBJFILE at the front of the list. */
398 objfile_to_front (struct objfile
*objfile
)
400 struct objfile
**objp
;
401 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
403 if (*objp
== objfile
)
405 /* Unhook it from where it is. */
406 *objp
= objfile
->next
;
407 /* Put it in the front. */
408 objfile
->next
= object_files
;
409 object_files
= objfile
;
415 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
418 It is not a bug, or error, to call this function if OBJFILE is not known
419 to be in the current list. This is done in the case of mapped objfiles,
420 for example, just to ensure that the mapped objfile doesn't appear twice
421 in the list. Since the list is threaded, linking in a mapped objfile
422 twice would create a circular list.
424 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
425 unlinking it, just to ensure that we have completely severed any linkages
426 between the OBJFILE and the list. */
429 unlink_objfile (struct objfile
*objfile
)
431 struct objfile
**objpp
;
433 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
435 if (*objpp
== objfile
)
437 *objpp
= (*objpp
)->next
;
438 objfile
->next
= NULL
;
443 internal_error (__FILE__
, __LINE__
,
444 _("unlink_objfile: objfile already unlinked"));
447 /* Add OBJFILE as a separate debug objfile of PARENT. */
450 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
452 gdb_assert (objfile
&& parent
);
454 /* Must not be already in a list. */
455 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
456 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
458 objfile
->separate_debug_objfile_backlink
= parent
;
459 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
460 parent
->separate_debug_objfile
= objfile
;
462 /* Put the separate debug object before the normal one, this is so that
463 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
464 put_objfile_before (objfile
, parent
);
467 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
471 free_objfile_separate_debug (struct objfile
*objfile
)
473 struct objfile
*child
;
475 for (child
= objfile
->separate_debug_objfile
; child
;)
477 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
478 free_objfile (child
);
483 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
484 that as much as possible is allocated on the objfile_obstack
485 so that the memory can be efficiently freed.
487 Things which we do NOT free because they are not in malloc'd memory
488 or not in memory specific to the objfile include:
492 FIXME: If the objfile is using reusable symbol information (via mmalloc),
493 then we need to take into account the fact that more than one process
494 may be using the symbol information at the same time (when mmalloc is
495 extended to support cooperative locking). When more than one process
496 is using the mapped symbol info, we need to be more careful about when
497 we free objects in the reusable area. */
500 free_objfile (struct objfile
*objfile
)
502 /* Free all separate debug objfiles. */
503 free_objfile_separate_debug (objfile
);
505 if (objfile
->separate_debug_objfile_backlink
)
507 /* We freed the separate debug file, make sure the base objfile
508 doesn't reference it. */
509 struct objfile
*child
;
511 child
= objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
;
513 if (child
== objfile
)
515 /* OBJFILE is the first child. */
516 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
=
517 objfile
->separate_debug_objfile_link
;
521 /* Find OBJFILE in the list. */
524 if (child
->separate_debug_objfile_link
== objfile
)
526 child
->separate_debug_objfile_link
=
527 objfile
->separate_debug_objfile_link
;
530 child
= child
->separate_debug_objfile_link
;
536 /* Remove any references to this objfile in the global value
538 preserve_values (objfile
);
540 /* It still may reference data modules have associated with the objfile and
541 the symbol file data. */
542 forget_cached_source_info_for_objfile (objfile
);
544 /* First do any symbol file specific actions required when we are
545 finished with a particular symbol file. Note that if the objfile
546 is using reusable symbol information (via mmalloc) then each of
547 these routines is responsible for doing the correct thing, either
548 freeing things which are valid only during this particular gdb
549 execution, or leaving them to be reused during the next one. */
551 if (objfile
->sf
!= NULL
)
553 (*objfile
->sf
->sym_finish
) (objfile
);
556 /* Discard any data modules have associated with the objfile. The function
557 still may reference objfile->obfd. */
558 objfile_free_data (objfile
);
560 gdb_bfd_unref (objfile
->obfd
);
562 /* Remove it from the chain of all objfiles. */
564 unlink_objfile (objfile
);
566 if (objfile
== symfile_objfile
)
567 symfile_objfile
= NULL
;
569 if (objfile
== rt_common_objfile
)
570 rt_common_objfile
= NULL
;
572 /* Before the symbol table code was redone to make it easier to
573 selectively load and remove information particular to a specific
574 linkage unit, gdb used to do these things whenever the monolithic
575 symbol table was blown away. How much still needs to be done
576 is unknown, but we play it safe for now and keep each action until
577 it is shown to be no longer needed. */
579 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
580 for example), so we need to call this here. */
581 clear_pc_function_cache ();
583 /* Clear globals which might have pointed into a removed objfile.
584 FIXME: It's not clear which of these are supposed to persist
585 between expressions and which ought to be reset each time. */
586 expression_context_block
= NULL
;
587 innermost_block
= NULL
;
589 /* Check to see if the current_source_symtab belongs to this objfile,
590 and if so, call clear_current_source_symtab_and_line. */
593 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
595 if (cursal
.symtab
&& cursal
.symtab
->objfile
== objfile
)
596 clear_current_source_symtab_and_line ();
599 /* The last thing we do is free the objfile struct itself. */
601 xfree (objfile
->name
);
602 if (objfile
->global_psymbols
.list
)
603 xfree (objfile
->global_psymbols
.list
);
604 if (objfile
->static_psymbols
.list
)
605 xfree (objfile
->static_psymbols
.list
);
606 /* Free the obstacks for non-reusable objfiles. */
607 psymbol_bcache_free (objfile
->psymbol_cache
);
608 bcache_xfree (objfile
->macro_cache
);
609 bcache_xfree (objfile
->filename_cache
);
610 if (objfile
->demangled_names_hash
)
611 htab_delete (objfile
->demangled_names_hash
);
612 obstack_free (&objfile
->objfile_obstack
, 0);
614 /* Rebuild section map next time we need it. */
615 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
621 do_free_objfile_cleanup (void *obj
)
627 make_cleanup_free_objfile (struct objfile
*obj
)
629 return make_cleanup (do_free_objfile_cleanup
, obj
);
632 /* Free all the object files at once and clean up their users. */
635 free_all_objfiles (void)
637 struct objfile
*objfile
, *temp
;
640 /* Any objfile referencewould become stale. */
641 for (so
= master_so_list (); so
; so
= so
->next
)
642 gdb_assert (so
->objfile
== NULL
);
644 ALL_OBJFILES_SAFE (objfile
, temp
)
646 free_objfile (objfile
);
648 clear_symtab_users (0);
651 /* A helper function for objfile_relocate1 that relocates a single
655 relocate_one_symbol (struct symbol
*sym
, struct objfile
*objfile
,
656 struct section_offsets
*delta
)
658 fixup_symbol_section (sym
, objfile
);
660 /* The RS6000 code from which this was taken skipped
661 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
662 But I'm leaving out that test, on the theory that
663 they can't possibly pass the tests below. */
664 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
665 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
666 && SYMBOL_SECTION (sym
) >= 0)
668 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (delta
, SYMBOL_SECTION (sym
));
672 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
673 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
674 Return non-zero iff any change happened. */
677 objfile_relocate1 (struct objfile
*objfile
,
678 struct section_offsets
*new_offsets
)
680 struct obj_section
*s
;
681 struct section_offsets
*delta
=
682 ((struct section_offsets
*)
683 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
686 int something_changed
= 0;
688 for (i
= 0; i
< objfile
->num_sections
; ++i
)
691 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
692 if (ANOFFSET (delta
, i
) != 0)
693 something_changed
= 1;
695 if (!something_changed
)
698 /* OK, get all the symtabs. */
702 ALL_OBJFILE_SYMTABS (objfile
, s
)
705 struct blockvector
*bv
;
708 /* First the line table. */
712 for (i
= 0; i
< l
->nitems
; ++i
)
713 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
716 /* Don't relocate a shared blockvector more than once. */
720 bv
= BLOCKVECTOR (s
);
721 if (BLOCKVECTOR_MAP (bv
))
722 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
723 ANOFFSET (delta
, s
->block_line_section
));
725 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
729 struct dict_iterator iter
;
731 b
= BLOCKVECTOR_BLOCK (bv
, i
);
732 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
733 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
735 /* We only want to iterate over the local symbols, not any
736 symbols in included symtabs. */
737 ALL_DICT_SYMBOLS (BLOCK_DICT (b
), iter
, sym
)
739 relocate_one_symbol (sym
, objfile
, delta
);
745 /* Relocate isolated symbols. */
749 for (iter
= objfile
->template_symbols
; iter
; iter
= iter
->hash_next
)
750 relocate_one_symbol (iter
, objfile
, delta
);
753 if (objfile
->psymtabs_addrmap
)
754 addrmap_relocate (objfile
->psymtabs_addrmap
,
755 ANOFFSET (delta
, SECT_OFF_TEXT (objfile
)));
758 objfile
->sf
->qf
->relocate (objfile
, new_offsets
, delta
);
761 struct minimal_symbol
*msym
;
763 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
764 if (SYMBOL_SECTION (msym
) >= 0)
765 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
767 /* Relocating different sections by different amounts may cause the symbols
768 to be out of order. */
769 msymbols_sort (objfile
);
771 if (objfile
->ei
.entry_point_p
)
773 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
774 only as a fallback. */
775 struct obj_section
*s
;
776 s
= find_pc_section (objfile
->ei
.entry_point
);
778 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
780 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
786 for (i
= 0; i
< objfile
->num_sections
; ++i
)
787 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
790 /* Rebuild section map next time we need it. */
791 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
793 /* Update the table in exec_ops, used to read memory. */
794 ALL_OBJFILE_OSECTIONS (objfile
, s
)
796 int idx
= s
->the_bfd_section
->index
;
798 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
799 obj_section_addr (s
));
802 /* Relocating probes. */
803 if (objfile
->sf
&& objfile
->sf
->sym_probe_fns
)
804 objfile
->sf
->sym_probe_fns
->sym_relocate_probe (objfile
,
811 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
812 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
814 The number and ordering of sections does differ between the two objfiles.
815 Only their names match. Also the file offsets will differ (objfile being
816 possibly prelinked but separate_debug_objfile is probably not prelinked) but
817 the in-memory absolute address as specified by NEW_OFFSETS must match both
821 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
823 struct objfile
*debug_objfile
;
826 changed
|= objfile_relocate1 (objfile
, new_offsets
);
828 for (debug_objfile
= objfile
->separate_debug_objfile
;
830 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
832 struct section_addr_info
*objfile_addrs
;
833 struct section_offsets
*new_debug_offsets
;
834 struct cleanup
*my_cleanups
;
836 objfile_addrs
= build_section_addr_info_from_objfile (objfile
);
837 my_cleanups
= make_cleanup (xfree
, objfile_addrs
);
839 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
840 relative ones must be already created according to debug_objfile. */
842 addr_info_make_relative (objfile_addrs
, debug_objfile
->obfd
);
844 gdb_assert (debug_objfile
->num_sections
845 == bfd_count_sections (debug_objfile
->obfd
));
847 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile
->num_sections
));
848 make_cleanup (xfree
, new_debug_offsets
);
849 relative_addr_info_to_section_offsets (new_debug_offsets
,
850 debug_objfile
->num_sections
,
853 changed
|= objfile_relocate1 (debug_objfile
, new_debug_offsets
);
855 do_cleanups (my_cleanups
);
858 /* Relocate breakpoints as necessary, after things are relocated. */
860 breakpoint_re_set ();
863 /* Return non-zero if OBJFILE has partial symbols. */
866 objfile_has_partial_symbols (struct objfile
*objfile
)
871 /* If we have not read psymbols, but we have a function capable of reading
872 them, then that is an indication that they are in fact available. Without
873 this function the symbols may have been already read in but they also may
874 not be present in this objfile. */
875 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0
876 && objfile
->sf
->sym_read_psymbols
!= NULL
)
879 return objfile
->sf
->qf
->has_symbols (objfile
);
882 /* Return non-zero if OBJFILE has full symbols. */
885 objfile_has_full_symbols (struct objfile
*objfile
)
887 return objfile
->symtabs
!= NULL
;
890 /* Return non-zero if OBJFILE has full or partial symbols, either directly
891 or through a separate debug file. */
894 objfile_has_symbols (struct objfile
*objfile
)
898 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
899 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
905 /* Many places in gdb want to test just to see if we have any partial
906 symbols available. This function returns zero if none are currently
907 available, nonzero otherwise. */
910 have_partial_symbols (void)
916 if (objfile_has_partial_symbols (ofp
))
922 /* Many places in gdb want to test just to see if we have any full
923 symbols available. This function returns zero if none are currently
924 available, nonzero otherwise. */
927 have_full_symbols (void)
933 if (objfile_has_full_symbols (ofp
))
940 /* This operations deletes all objfile entries that represent solibs that
941 weren't explicitly loaded by the user, via e.g., the add-symbol-file
945 objfile_purge_solibs (void)
947 struct objfile
*objf
;
948 struct objfile
*temp
;
950 ALL_OBJFILES_SAFE (objf
, temp
)
952 /* We assume that the solib package has been purged already, or will
955 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
961 /* Many places in gdb want to test just to see if we have any minimal
962 symbols available. This function returns zero if none are currently
963 available, nonzero otherwise. */
966 have_minimal_symbols (void)
972 if (ofp
->minimal_symbol_count
> 0)
980 /* Qsort comparison function. */
983 qsort_cmp (const void *a
, const void *b
)
985 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
986 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
987 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
988 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
990 if (sect1_addr
< sect2_addr
)
992 else if (sect1_addr
> sect2_addr
)
996 /* Sections are at the same address. This could happen if
997 A) we have an objfile and a separate debuginfo.
998 B) we are confused, and have added sections without proper relocation,
999 or something like that. */
1001 const struct objfile
*const objfile1
= sect1
->objfile
;
1002 const struct objfile
*const objfile2
= sect2
->objfile
;
1004 if (objfile1
->separate_debug_objfile
== objfile2
1005 || objfile2
->separate_debug_objfile
== objfile1
)
1007 /* Case A. The ordering doesn't matter: separate debuginfo files
1008 will be filtered out later. */
1013 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1014 triage. This section could be slow (since we iterate over all
1015 objfiles in each call to qsort_cmp), but this shouldn't happen
1016 very often (GDB is already in a confused state; one hopes this
1017 doesn't happen at all). If you discover that significant time is
1018 spent in the loops below, do 'set complaints 100' and examine the
1019 resulting complaints. */
1021 if (objfile1
== objfile2
)
1023 /* Both sections came from the same objfile. We are really confused.
1024 Sort on sequence order of sections within the objfile. */
1026 const struct obj_section
*osect
;
1028 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1031 else if (osect
== sect2
)
1034 /* We should have found one of the sections before getting here. */
1035 gdb_assert_not_reached ("section not found");
1039 /* Sort on sequence number of the objfile in the chain. */
1041 const struct objfile
*objfile
;
1043 ALL_OBJFILES (objfile
)
1044 if (objfile
== objfile1
)
1046 else if (objfile
== objfile2
)
1049 /* We should have found one of the objfiles before getting here. */
1050 gdb_assert_not_reached ("objfile not found");
1055 gdb_assert_not_reached ("unexpected code path");
1059 /* Select "better" obj_section to keep. We prefer the one that came from
1060 the real object, rather than the one from separate debuginfo.
1061 Most of the time the two sections are exactly identical, but with
1062 prelinking the .rel.dyn section in the real object may have different
1065 static struct obj_section
*
1066 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
1068 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
1069 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
1070 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
1071 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
1072 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
1074 if (a
->objfile
->separate_debug_objfile
!= NULL
)
1079 /* Return 1 if SECTION should be inserted into the section map.
1080 We want to insert only non-overlay and non-TLS section. */
1083 insert_section_p (const struct bfd
*abfd
,
1084 const struct bfd_section
*section
)
1086 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
1088 if (overlay_debugging
&& lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
1089 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
1090 /* This is an overlay section. IN_MEMORY check is needed to avoid
1091 discarding sections from the "system supplied DSO" (aka vdso)
1092 on some Linux systems (e.g. Fedora 11). */
1094 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
1095 /* This is a TLS section. */
1101 /* Filter out overlapping sections where one section came from the real
1102 objfile, and the other from a separate debuginfo file.
1103 Return the size of table after redundant sections have been eliminated. */
1106 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1110 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1112 struct obj_section
*const sect1
= map
[i
];
1113 struct obj_section
*const sect2
= map
[i
+ 1];
1114 const struct objfile
*const objfile1
= sect1
->objfile
;
1115 const struct objfile
*const objfile2
= sect2
->objfile
;
1116 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1117 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1119 if (sect1_addr
== sect2_addr
1120 && (objfile1
->separate_debug_objfile
== objfile2
1121 || objfile2
->separate_debug_objfile
== objfile1
))
1123 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1132 gdb_assert (i
== map_size
- 1);
1136 /* The map should not have shrunk to less than half the original size. */
1137 gdb_assert (map_size
/ 2 <= j
);
1142 /* Filter out overlapping sections, issuing a warning if any are found.
1143 Overlapping sections could really be overlay sections which we didn't
1144 classify as such in insert_section_p, or we could be dealing with a
1148 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1152 for (i
= 0, j
= 0; i
< map_size
- 1; )
1157 for (k
= i
+ 1; k
< map_size
; k
++)
1159 struct obj_section
*const sect1
= map
[i
];
1160 struct obj_section
*const sect2
= map
[k
];
1161 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1162 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1163 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1165 gdb_assert (sect1_addr
<= sect2_addr
);
1167 if (sect1_endaddr
<= sect2_addr
)
1171 /* We have an overlap. Report it. */
1173 struct objfile
*const objf1
= sect1
->objfile
;
1174 struct objfile
*const objf2
= sect2
->objfile
;
1176 const struct bfd
*const abfd1
= objf1
->obfd
;
1177 const struct bfd
*const abfd2
= objf2
->obfd
;
1179 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1180 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1182 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1184 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1186 complaint (&symfile_complaints
,
1187 _("unexpected overlap between:\n"
1188 " (A) section `%s' from `%s' [%s, %s)\n"
1189 " (B) section `%s' from `%s' [%s, %s).\n"
1190 "Will ignore section B"),
1191 bfd_section_name (abfd1
, bfds1
), objf1
->name
,
1192 paddress (gdbarch
, sect1_addr
),
1193 paddress (gdbarch
, sect1_endaddr
),
1194 bfd_section_name (abfd2
, bfds2
), objf2
->name
,
1195 paddress (gdbarch
, sect2_addr
),
1196 paddress (gdbarch
, sect2_endaddr
));
1204 gdb_assert (i
== map_size
- 1);
1212 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1213 TLS, overlay and overlapping sections. */
1216 update_section_map (struct program_space
*pspace
,
1217 struct obj_section
***pmap
, int *pmap_size
)
1219 int alloc_size
, map_size
, i
;
1220 struct obj_section
*s
, **map
;
1221 struct objfile
*objfile
;
1223 gdb_assert (get_objfile_pspace_data (pspace
)->objfiles_changed_p
!= 0);
1229 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1230 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1231 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1234 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1235 if (alloc_size
== 0)
1242 map
= xmalloc (alloc_size
* sizeof (*map
));
1245 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1246 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1247 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1250 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1251 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1252 map_size
= filter_overlapping_sections(map
, map_size
);
1254 if (map_size
< alloc_size
)
1255 /* Some sections were eliminated. Trim excess space. */
1256 map
= xrealloc (map
, map_size
* sizeof (*map
));
1258 gdb_assert (alloc_size
== map_size
);
1261 *pmap_size
= map_size
;
1264 /* Bsearch comparison function. */
1267 bsearch_cmp (const void *key
, const void *elt
)
1269 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1270 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1272 if (pc
< obj_section_addr (section
))
1274 if (pc
< obj_section_endaddr (section
))
1279 /* Returns a section whose range includes PC or NULL if none found. */
1281 struct obj_section
*
1282 find_pc_section (CORE_ADDR pc
)
1284 struct objfile_pspace_info
*pspace_info
;
1285 struct obj_section
*s
, **sp
;
1287 /* Check for mapped overlay section first. */
1288 s
= find_pc_mapped_section (pc
);
1292 pspace_info
= get_objfile_pspace_data (current_program_space
);
1293 if (pspace_info
->objfiles_changed_p
!= 0)
1295 update_section_map (current_program_space
,
1296 &pspace_info
->sections
,
1297 &pspace_info
->num_sections
);
1299 /* Don't need updates to section map until objfiles are added,
1300 removed or relocated. */
1301 pspace_info
->objfiles_changed_p
= 0;
1304 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1305 bsearch be non-NULL. */
1306 if (pspace_info
->sections
== NULL
)
1308 gdb_assert (pspace_info
->num_sections
== 0);
1312 sp
= (struct obj_section
**) bsearch (&pc
,
1313 pspace_info
->sections
,
1314 pspace_info
->num_sections
,
1315 sizeof (*pspace_info
->sections
),
1323 /* In SVR4, we recognize a trampoline by it's section name.
1324 That is, if the pc is in a section named ".plt" then we are in
1328 in_plt_section (CORE_ADDR pc
, char *name
)
1330 struct obj_section
*s
;
1333 s
= find_pc_section (pc
);
1336 && s
->the_bfd_section
->name
!= NULL
1337 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
1342 /* Keep a registry of per-objfile data-pointers required by other GDB
1348 void (*save
) (struct objfile
*, void *);
1349 void (*free
) (struct objfile
*, void *);
1352 struct objfile_data_registration
1354 struct objfile_data
*data
;
1355 struct objfile_data_registration
*next
;
1358 struct objfile_data_registry
1360 struct objfile_data_registration
*registrations
;
1361 unsigned num_registrations
;
1364 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
1366 const struct objfile_data
*
1367 register_objfile_data_with_cleanup (void (*save
) (struct objfile
*, void *),
1368 void (*free
) (struct objfile
*, void *))
1370 struct objfile_data_registration
**curr
;
1372 /* Append new registration. */
1373 for (curr
= &objfile_data_registry
.registrations
;
1374 *curr
!= NULL
; curr
= &(*curr
)->next
);
1376 *curr
= XMALLOC (struct objfile_data_registration
);
1377 (*curr
)->next
= NULL
;
1378 (*curr
)->data
= XMALLOC (struct objfile_data
);
1379 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
1380 (*curr
)->data
->save
= save
;
1381 (*curr
)->data
->free
= free
;
1383 return (*curr
)->data
;
1386 const struct objfile_data
*
1387 register_objfile_data (void)
1389 return register_objfile_data_with_cleanup (NULL
, NULL
);
1393 objfile_alloc_data (struct objfile
*objfile
)
1395 gdb_assert (objfile
->data
== NULL
);
1396 objfile
->num_data
= objfile_data_registry
.num_registrations
;
1397 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
1401 objfile_free_data (struct objfile
*objfile
)
1403 gdb_assert (objfile
->data
!= NULL
);
1404 clear_objfile_data (objfile
);
1405 xfree (objfile
->data
);
1406 objfile
->data
= NULL
;
1410 clear_objfile_data (struct objfile
*objfile
)
1412 struct objfile_data_registration
*registration
;
1415 gdb_assert (objfile
->data
!= NULL
);
1417 /* Process all the save handlers. */
1419 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1420 i
< objfile
->num_data
;
1421 registration
= registration
->next
, i
++)
1422 if (objfile
->data
[i
] != NULL
&& registration
->data
->save
!= NULL
)
1423 registration
->data
->save (objfile
, objfile
->data
[i
]);
1425 /* Now process all the free handlers. */
1427 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1428 i
< objfile
->num_data
;
1429 registration
= registration
->next
, i
++)
1430 if (objfile
->data
[i
] != NULL
&& registration
->data
->free
!= NULL
)
1431 registration
->data
->free (objfile
, objfile
->data
[i
]);
1433 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
1437 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
1440 gdb_assert (data
->index
< objfile
->num_data
);
1441 objfile
->data
[data
->index
] = value
;
1445 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
1447 gdb_assert (data
->index
< objfile
->num_data
);
1448 return objfile
->data
[data
->index
];
1451 /* Set objfiles_changed_p so section map will be rebuilt next time it
1452 is used. Called by reread_symbols. */
1455 objfiles_changed (void)
1457 /* Rebuild section map next time we need it. */
1458 get_objfile_pspace_data (current_program_space
)->objfiles_changed_p
= 1;
1461 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1462 gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
1463 searching the objfiles in the order they are stored internally,
1464 ignoring CURRENT_OBJFILE.
1466 On most platorms, it should be close enough to doing the best
1467 we can without some knowledge specific to the architecture. */
1470 default_iterate_over_objfiles_in_search_order
1471 (struct gdbarch
*gdbarch
,
1472 iterate_over_objfiles_in_search_order_cb_ftype
*cb
,
1473 void *cb_data
, struct objfile
*current_objfile
)
1476 struct objfile
*objfile
;
1478 ALL_OBJFILES (objfile
)
1480 stop
= cb (objfile
, cb_data
);
1486 /* Provide a prototype to silence -Wmissing-prototypes. */
1487 extern initialize_file_ftype _initialize_objfiles
;
1490 _initialize_objfiles (void)
1492 objfiles_pspace_data
1493 = register_program_space_data_with_cleanup (objfiles_pspace_data_cleanup
);