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"
57 /* Prototypes for local functions */
59 static void objfile_alloc_data (struct objfile
*objfile
);
60 static void objfile_free_data (struct objfile
*objfile
);
62 /* Externally visible variables that are owned by this module.
63 See declarations in objfile.h for more info. */
65 struct objfile
*rt_common_objfile
; /* For runtime common symbols */
67 struct objfile_pspace_info
69 int objfiles_changed_p
;
70 struct obj_section
**sections
;
74 /* Per-program-space data key. */
75 static const struct program_space_data
*objfiles_pspace_data
;
78 objfiles_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
80 struct objfile_pspace_info
*info
;
82 info
= program_space_data (pspace
, objfiles_pspace_data
);
85 xfree (info
->sections
);
90 /* Get the current svr4 data. If none is found yet, add it now. This
91 function always returns a valid object. */
93 static struct objfile_pspace_info
*
94 get_objfile_pspace_data (struct program_space
*pspace
)
96 struct objfile_pspace_info
*info
;
98 info
= program_space_data (pspace
, objfiles_pspace_data
);
101 info
= XZALLOC (struct objfile_pspace_info
);
102 set_program_space_data (pspace
, objfiles_pspace_data
, info
);
108 /* Records whether any objfiles appeared or disappeared since we last updated
109 address to obj section map. */
111 /* Locate all mappable sections of a BFD file.
112 objfile_p_char is a char * to get it through
113 bfd_map_over_sections; we cast it back to its proper type. */
115 /* Called via bfd_map_over_sections to build up the section table that
116 the objfile references. The objfile contains pointers to the start
117 of the table (objfile->sections) and to the first location after
118 the end of the table (objfile->sections_end). */
121 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
122 void *objfile_p_char
)
124 struct objfile
*objfile
= (struct objfile
*) objfile_p_char
;
125 struct obj_section section
;
128 aflag
= bfd_get_section_flags (abfd
, asect
);
130 if (!(aflag
& SEC_ALLOC
))
133 if (0 == bfd_section_size (abfd
, asect
))
135 section
.objfile
= objfile
;
136 section
.the_bfd_section
= asect
;
137 section
.ovly_mapped
= 0;
138 obstack_grow (&objfile
->objfile_obstack
,
139 (char *) §ion
, sizeof (section
));
140 objfile
->sections_end
141 = (struct obj_section
*) (((size_t) objfile
->sections_end
) + 1);
144 /* Builds a section table for OBJFILE.
145 Returns 0 if OK, 1 on error (in which case bfd_error contains the
148 Note that while we are building the table, which goes into the
149 psymbol obstack, we hijack the sections_end pointer to instead hold
150 a count of the number of sections. When bfd_map_over_sections
151 returns, this count is used to compute the pointer to the end of
152 the sections table, which then overwrites the count.
154 Also note that the OFFSET and OVLY_MAPPED in each table entry
155 are initialized to zero.
157 Also note that if anything else writes to the psymbol obstack while
158 we are building the table, we're pretty much hosed. */
161 build_objfile_section_table (struct objfile
*objfile
)
163 objfile
->sections_end
= 0;
164 bfd_map_over_sections (objfile
->obfd
,
165 add_to_objfile_sections
, (void *) objfile
);
166 objfile
->sections
= obstack_finish (&objfile
->objfile_obstack
);
167 objfile
->sections_end
= objfile
->sections
+ (size_t) objfile
->sections_end
;
171 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
172 allocate a new objfile struct, fill it in as best we can, link it
173 into the list of all known objfiles, and return a pointer to the
176 The FLAGS word contains various bits (OBJF_*) that can be taken as
177 requests for specific operations. Other bits like OBJF_SHARED are
178 simply copied through to the new objfile flags member. */
180 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
181 by jv-lang.c, to create an artificial objfile used to hold
182 information about dynamically-loaded Java classes. Unfortunately,
183 that branch of this function doesn't get tested very frequently, so
184 it's prone to breakage. (E.g. at one time the name was set to NULL
185 in that situation, which broke a loop over all names in the dynamic
186 library loader.) If you change this function, please try to leave
187 things in a consistent state even if abfd is NULL. */
190 allocate_objfile (bfd
*abfd
, int flags
)
192 struct objfile
*objfile
;
194 objfile
= (struct objfile
*) xzalloc (sizeof (struct objfile
));
195 objfile
->psymbol_cache
= psymbol_bcache_init ();
196 objfile
->macro_cache
= bcache_xmalloc (NULL
, NULL
);
197 objfile
->filename_cache
= bcache_xmalloc (NULL
, NULL
);
198 /* We could use obstack_specify_allocation here instead, but
199 gdb_obstack.h specifies the alloc/dealloc functions. */
200 obstack_init (&objfile
->objfile_obstack
);
201 terminate_minimal_symbol_table (objfile
);
203 objfile_alloc_data (objfile
);
205 /* Update the per-objfile information that comes from the bfd, ensuring
206 that any data that is reference is saved in the per-objfile data
209 objfile
->obfd
= gdb_bfd_ref (abfd
);
212 /* Look up the gdbarch associated with the BFD. */
213 objfile
->gdbarch
= gdbarch_from_bfd (abfd
);
215 objfile
->name
= xstrdup (bfd_get_filename (abfd
));
216 objfile
->mtime
= bfd_get_mtime (abfd
);
218 /* Build section table. */
220 if (build_objfile_section_table (objfile
))
222 error (_("Can't find the file sections in `%s': %s"),
223 objfile
->name
, bfd_errmsg (bfd_get_error ()));
228 objfile
->name
= xstrdup ("<<anonymous objfile>>");
231 objfile
->pspace
= current_program_space
;
233 /* Initialize the section indexes for this objfile, so that we can
234 later detect if they are used w/o being properly assigned to. */
236 objfile
->sect_index_text
= -1;
237 objfile
->sect_index_data
= -1;
238 objfile
->sect_index_bss
= -1;
239 objfile
->sect_index_rodata
= -1;
241 /* Add this file onto the tail of the linked list of other such files. */
243 objfile
->next
= NULL
;
244 if (object_files
== NULL
)
245 object_files
= objfile
;
248 struct objfile
*last_one
;
250 for (last_one
= object_files
;
252 last_one
= last_one
->next
);
253 last_one
->next
= objfile
;
256 /* Save passed in flag bits. */
257 objfile
->flags
|= flags
;
259 /* Rebuild section map next time we need it. */
260 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
265 /* Retrieve the gdbarch associated with OBJFILE. */
267 get_objfile_arch (struct objfile
*objfile
)
269 return objfile
->gdbarch
;
272 /* Initialize entry point information for this objfile. */
275 init_entry_point_info (struct objfile
*objfile
)
277 /* Save startup file's range of PC addresses to help blockframe.c
278 decide where the bottom of the stack is. */
280 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
282 /* Executable file -- record its entry point so we'll recognize
283 the startup file because it contains the entry point. */
284 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
285 objfile
->ei
.entry_point_p
= 1;
287 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
288 && bfd_get_start_address (objfile
->obfd
) != 0)
290 /* Some shared libraries may have entry points set and be
291 runnable. There's no clear way to indicate this, so just check
292 for values other than zero. */
293 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
294 objfile
->ei
.entry_point_p
= 1;
298 /* Examination of non-executable.o files. Short-circuit this stuff. */
299 objfile
->ei
.entry_point_p
= 0;
303 /* If there is a valid and known entry point, function fills *ENTRY_P with it
304 and returns non-zero; otherwise it returns zero. */
307 entry_point_address_query (CORE_ADDR
*entry_p
)
309 struct gdbarch
*gdbarch
;
310 CORE_ADDR entry_point
;
312 if (symfile_objfile
== NULL
|| !symfile_objfile
->ei
.entry_point_p
)
315 gdbarch
= get_objfile_arch (symfile_objfile
);
317 entry_point
= symfile_objfile
->ei
.entry_point
;
319 /* Make certain that the address points at real code, and not a
320 function descriptor. */
321 entry_point
= gdbarch_convert_from_func_ptr_addr (gdbarch
, entry_point
,
324 /* Remove any ISA markers, so that this matches entries in the
326 entry_point
= gdbarch_addr_bits_remove (gdbarch
, entry_point
);
328 *entry_p
= entry_point
;
332 /* Get current entry point address. Call error if it is not known. */
335 entry_point_address (void)
339 if (!entry_point_address_query (&retval
))
340 error (_("Entry point address is not known."));
345 /* Iterator on PARENT and every separate debug objfile of PARENT.
346 The usage pattern is:
347 for (objfile = parent;
349 objfile = objfile_separate_debug_iterate (parent, objfile))
354 objfile_separate_debug_iterate (const struct objfile
*parent
,
355 const struct objfile
*objfile
)
359 /* If any, return the first child. */
360 res
= objfile
->separate_debug_objfile
;
364 /* Common case where there is no separate debug objfile. */
365 if (objfile
== parent
)
368 /* Return the brother if any. Note that we don't iterate on brothers of
370 res
= objfile
->separate_debug_objfile_link
;
374 for (res
= objfile
->separate_debug_objfile_backlink
;
376 res
= res
->separate_debug_objfile_backlink
)
378 gdb_assert (res
!= NULL
);
379 if (res
->separate_debug_objfile_link
)
380 return res
->separate_debug_objfile_link
;
385 /* Put one object file before a specified on in the global list.
386 This can be used to make sure an object file is destroyed before
387 another when using ALL_OBJFILES_SAFE to free all objfiles. */
389 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
391 struct objfile
**objp
;
393 unlink_objfile (objfile
);
395 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
397 if (*objp
== before_this
)
399 objfile
->next
= *objp
;
405 internal_error (__FILE__
, __LINE__
,
406 _("put_objfile_before: before objfile not in list"));
409 /* Put OBJFILE at the front of the list. */
412 objfile_to_front (struct objfile
*objfile
)
414 struct objfile
**objp
;
415 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
417 if (*objp
== objfile
)
419 /* Unhook it from where it is. */
420 *objp
= objfile
->next
;
421 /* Put it in the front. */
422 objfile
->next
= object_files
;
423 object_files
= objfile
;
429 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
432 It is not a bug, or error, to call this function if OBJFILE is not known
433 to be in the current list. This is done in the case of mapped objfiles,
434 for example, just to ensure that the mapped objfile doesn't appear twice
435 in the list. Since the list is threaded, linking in a mapped objfile
436 twice would create a circular list.
438 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
439 unlinking it, just to ensure that we have completely severed any linkages
440 between the OBJFILE and the list. */
443 unlink_objfile (struct objfile
*objfile
)
445 struct objfile
**objpp
;
447 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
449 if (*objpp
== objfile
)
451 *objpp
= (*objpp
)->next
;
452 objfile
->next
= NULL
;
457 internal_error (__FILE__
, __LINE__
,
458 _("unlink_objfile: objfile already unlinked"));
461 /* Add OBJFILE as a separate debug objfile of PARENT. */
464 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
466 gdb_assert (objfile
&& parent
);
468 /* Must not be already in a list. */
469 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
470 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
472 objfile
->separate_debug_objfile_backlink
= parent
;
473 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
474 parent
->separate_debug_objfile
= objfile
;
476 /* Put the separate debug object before the normal one, this is so that
477 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
478 put_objfile_before (objfile
, parent
);
481 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
485 free_objfile_separate_debug (struct objfile
*objfile
)
487 struct objfile
*child
;
489 for (child
= objfile
->separate_debug_objfile
; child
;)
491 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
492 free_objfile (child
);
497 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
498 that as much as possible is allocated on the objfile_obstack
499 so that the memory can be efficiently freed.
501 Things which we do NOT free because they are not in malloc'd memory
502 or not in memory specific to the objfile include:
506 FIXME: If the objfile is using reusable symbol information (via mmalloc),
507 then we need to take into account the fact that more than one process
508 may be using the symbol information at the same time (when mmalloc is
509 extended to support cooperative locking). When more than one process
510 is using the mapped symbol info, we need to be more careful about when
511 we free objects in the reusable area. */
514 free_objfile (struct objfile
*objfile
)
516 /* Free all separate debug objfiles. */
517 free_objfile_separate_debug (objfile
);
519 if (objfile
->separate_debug_objfile_backlink
)
521 /* We freed the separate debug file, make sure the base objfile
522 doesn't reference it. */
523 struct objfile
*child
;
525 child
= objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
;
527 if (child
== objfile
)
529 /* OBJFILE is the first child. */
530 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
=
531 objfile
->separate_debug_objfile_link
;
535 /* Find OBJFILE in the list. */
538 if (child
->separate_debug_objfile_link
== objfile
)
540 child
->separate_debug_objfile_link
=
541 objfile
->separate_debug_objfile_link
;
544 child
= child
->separate_debug_objfile_link
;
550 /* Remove any references to this objfile in the global value
552 preserve_values (objfile
);
554 /* It still may reference data modules have associated with the objfile and
555 the symbol file data. */
556 forget_cached_source_info_for_objfile (objfile
);
558 /* First do any symbol file specific actions required when we are
559 finished with a particular symbol file. Note that if the objfile
560 is using reusable symbol information (via mmalloc) then each of
561 these routines is responsible for doing the correct thing, either
562 freeing things which are valid only during this particular gdb
563 execution, or leaving them to be reused during the next one. */
565 if (objfile
->sf
!= NULL
)
567 (*objfile
->sf
->sym_finish
) (objfile
);
570 /* Discard any data modules have associated with the objfile. The function
571 still may reference objfile->obfd. */
572 objfile_free_data (objfile
);
574 gdb_bfd_unref (objfile
->obfd
);
576 /* Remove it from the chain of all objfiles. */
578 unlink_objfile (objfile
);
580 if (objfile
== symfile_objfile
)
581 symfile_objfile
= NULL
;
583 if (objfile
== rt_common_objfile
)
584 rt_common_objfile
= NULL
;
586 /* Before the symbol table code was redone to make it easier to
587 selectively load and remove information particular to a specific
588 linkage unit, gdb used to do these things whenever the monolithic
589 symbol table was blown away. How much still needs to be done
590 is unknown, but we play it safe for now and keep each action until
591 it is shown to be no longer needed. */
593 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
594 for example), so we need to call this here. */
595 clear_pc_function_cache ();
597 /* Clear globals which might have pointed into a removed objfile.
598 FIXME: It's not clear which of these are supposed to persist
599 between expressions and which ought to be reset each time. */
600 expression_context_block
= NULL
;
601 innermost_block
= NULL
;
603 /* Check to see if the current_source_symtab belongs to this objfile,
604 and if so, call clear_current_source_symtab_and_line. */
607 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
609 if (cursal
.symtab
&& cursal
.symtab
->objfile
== objfile
)
610 clear_current_source_symtab_and_line ();
613 /* The last thing we do is free the objfile struct itself. */
615 xfree (objfile
->name
);
616 if (objfile
->global_psymbols
.list
)
617 xfree (objfile
->global_psymbols
.list
);
618 if (objfile
->static_psymbols
.list
)
619 xfree (objfile
->static_psymbols
.list
);
620 /* Free the obstacks for non-reusable objfiles. */
621 psymbol_bcache_free (objfile
->psymbol_cache
);
622 bcache_xfree (objfile
->macro_cache
);
623 bcache_xfree (objfile
->filename_cache
);
624 if (objfile
->demangled_names_hash
)
625 htab_delete (objfile
->demangled_names_hash
);
626 obstack_free (&objfile
->objfile_obstack
, 0);
628 /* Rebuild section map next time we need it. */
629 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
635 do_free_objfile_cleanup (void *obj
)
641 make_cleanup_free_objfile (struct objfile
*obj
)
643 return make_cleanup (do_free_objfile_cleanup
, obj
);
646 /* Free all the object files at once and clean up their users. */
649 free_all_objfiles (void)
651 struct objfile
*objfile
, *temp
;
654 /* Any objfile referencewould become stale. */
655 for (so
= master_so_list (); so
; so
= so
->next
)
656 gdb_assert (so
->objfile
== NULL
);
658 ALL_OBJFILES_SAFE (objfile
, temp
)
660 free_objfile (objfile
);
662 clear_symtab_users (0);
665 /* A helper function for objfile_relocate1 that relocates a single
669 relocate_one_symbol (struct symbol
*sym
, struct objfile
*objfile
,
670 struct section_offsets
*delta
)
672 fixup_symbol_section (sym
, objfile
);
674 /* The RS6000 code from which this was taken skipped
675 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
676 But I'm leaving out that test, on the theory that
677 they can't possibly pass the tests below. */
678 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
679 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
680 && SYMBOL_SECTION (sym
) >= 0)
682 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (delta
, SYMBOL_SECTION (sym
));
686 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
687 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
688 Return non-zero iff any change happened. */
691 objfile_relocate1 (struct objfile
*objfile
,
692 struct section_offsets
*new_offsets
)
694 struct obj_section
*s
;
695 struct section_offsets
*delta
=
696 ((struct section_offsets
*)
697 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
700 int something_changed
= 0;
702 for (i
= 0; i
< objfile
->num_sections
; ++i
)
705 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
706 if (ANOFFSET (delta
, i
) != 0)
707 something_changed
= 1;
709 if (!something_changed
)
712 /* OK, get all the symtabs. */
716 ALL_OBJFILE_SYMTABS (objfile
, s
)
719 struct blockvector
*bv
;
722 /* First the line table. */
726 for (i
= 0; i
< l
->nitems
; ++i
)
727 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
730 /* Don't relocate a shared blockvector more than once. */
734 bv
= BLOCKVECTOR (s
);
735 if (BLOCKVECTOR_MAP (bv
))
736 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
737 ANOFFSET (delta
, s
->block_line_section
));
739 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
743 struct dict_iterator iter
;
745 b
= BLOCKVECTOR_BLOCK (bv
, i
);
746 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
747 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
749 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
751 relocate_one_symbol (sym
, objfile
, delta
);
757 /* Relocate isolated symbols. */
761 for (iter
= objfile
->template_symbols
; iter
; iter
= iter
->hash_next
)
762 relocate_one_symbol (iter
, objfile
, delta
);
765 if (objfile
->psymtabs_addrmap
)
766 addrmap_relocate (objfile
->psymtabs_addrmap
,
767 ANOFFSET (delta
, SECT_OFF_TEXT (objfile
)));
770 objfile
->sf
->qf
->relocate (objfile
, new_offsets
, delta
);
773 struct minimal_symbol
*msym
;
775 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
776 if (SYMBOL_SECTION (msym
) >= 0)
777 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
779 /* Relocating different sections by different amounts may cause the symbols
780 to be out of order. */
781 msymbols_sort (objfile
);
783 if (objfile
->ei
.entry_point_p
)
785 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
786 only as a fallback. */
787 struct obj_section
*s
;
788 s
= find_pc_section (objfile
->ei
.entry_point
);
790 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
792 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
798 for (i
= 0; i
< objfile
->num_sections
; ++i
)
799 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
802 /* Rebuild section map next time we need it. */
803 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
805 /* Update the table in exec_ops, used to read memory. */
806 ALL_OBJFILE_OSECTIONS (objfile
, s
)
808 int idx
= s
->the_bfd_section
->index
;
810 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
811 obj_section_addr (s
));
818 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
819 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
821 The number and ordering of sections does differ between the two objfiles.
822 Only their names match. Also the file offsets will differ (objfile being
823 possibly prelinked but separate_debug_objfile is probably not prelinked) but
824 the in-memory absolute address as specified by NEW_OFFSETS must match both
828 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
830 struct objfile
*debug_objfile
;
833 changed
|= objfile_relocate1 (objfile
, new_offsets
);
835 for (debug_objfile
= objfile
->separate_debug_objfile
;
837 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
839 struct section_addr_info
*objfile_addrs
;
840 struct section_offsets
*new_debug_offsets
;
841 struct cleanup
*my_cleanups
;
843 objfile_addrs
= build_section_addr_info_from_objfile (objfile
);
844 my_cleanups
= make_cleanup (xfree
, objfile_addrs
);
846 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
847 relative ones must be already created according to debug_objfile. */
849 addr_info_make_relative (objfile_addrs
, debug_objfile
->obfd
);
851 gdb_assert (debug_objfile
->num_sections
852 == bfd_count_sections (debug_objfile
->obfd
));
854 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile
->num_sections
));
855 make_cleanup (xfree
, new_debug_offsets
);
856 relative_addr_info_to_section_offsets (new_debug_offsets
,
857 debug_objfile
->num_sections
,
860 changed
|= objfile_relocate1 (debug_objfile
, new_debug_offsets
);
862 do_cleanups (my_cleanups
);
865 /* Relocate breakpoints as necessary, after things are relocated. */
867 breakpoint_re_set ();
870 /* Return non-zero if OBJFILE has partial symbols. */
873 objfile_has_partial_symbols (struct objfile
*objfile
)
878 /* If we have not read psymbols, but we have a function capable of reading
879 them, then that is an indication that they are in fact available. Without
880 this function the symbols may have been already read in but they also may
881 not be present in this objfile. */
882 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0
883 && objfile
->sf
->sym_read_psymbols
!= NULL
)
886 return objfile
->sf
->qf
->has_symbols (objfile
);
889 /* Return non-zero if OBJFILE has full symbols. */
892 objfile_has_full_symbols (struct objfile
*objfile
)
894 return objfile
->symtabs
!= NULL
;
897 /* Return non-zero if OBJFILE has full or partial symbols, either directly
898 or through a separate debug file. */
901 objfile_has_symbols (struct objfile
*objfile
)
905 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
906 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
912 /* Many places in gdb want to test just to see if we have any partial
913 symbols available. This function returns zero if none are currently
914 available, nonzero otherwise. */
917 have_partial_symbols (void)
923 if (objfile_has_partial_symbols (ofp
))
929 /* Many places in gdb want to test just to see if we have any full
930 symbols available. This function returns zero if none are currently
931 available, nonzero otherwise. */
934 have_full_symbols (void)
940 if (objfile_has_full_symbols (ofp
))
947 /* This operations deletes all objfile entries that represent solibs that
948 weren't explicitly loaded by the user, via e.g., the add-symbol-file
952 objfile_purge_solibs (void)
954 struct objfile
*objf
;
955 struct objfile
*temp
;
957 ALL_OBJFILES_SAFE (objf
, temp
)
959 /* We assume that the solib package has been purged already, or will
962 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
968 /* Many places in gdb want to test just to see if we have any minimal
969 symbols available. This function returns zero if none are currently
970 available, nonzero otherwise. */
973 have_minimal_symbols (void)
979 if (ofp
->minimal_symbol_count
> 0)
987 /* Qsort comparison function. */
990 qsort_cmp (const void *a
, const void *b
)
992 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
993 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
994 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
995 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
997 if (sect1_addr
< sect2_addr
)
999 else if (sect1_addr
> sect2_addr
)
1003 /* Sections are at the same address. This could happen if
1004 A) we have an objfile and a separate debuginfo.
1005 B) we are confused, and have added sections without proper relocation,
1006 or something like that. */
1008 const struct objfile
*const objfile1
= sect1
->objfile
;
1009 const struct objfile
*const objfile2
= sect2
->objfile
;
1011 if (objfile1
->separate_debug_objfile
== objfile2
1012 || objfile2
->separate_debug_objfile
== objfile1
)
1014 /* Case A. The ordering doesn't matter: separate debuginfo files
1015 will be filtered out later. */
1020 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1021 triage. This section could be slow (since we iterate over all
1022 objfiles in each call to qsort_cmp), but this shouldn't happen
1023 very often (GDB is already in a confused state; one hopes this
1024 doesn't happen at all). If you discover that significant time is
1025 spent in the loops below, do 'set complaints 100' and examine the
1026 resulting complaints. */
1028 if (objfile1
== objfile2
)
1030 /* Both sections came from the same objfile. We are really confused.
1031 Sort on sequence order of sections within the objfile. */
1033 const struct obj_section
*osect
;
1035 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1038 else if (osect
== sect2
)
1041 /* We should have found one of the sections before getting here. */
1042 gdb_assert_not_reached ("section not found");
1046 /* Sort on sequence number of the objfile in the chain. */
1048 const struct objfile
*objfile
;
1050 ALL_OBJFILES (objfile
)
1051 if (objfile
== objfile1
)
1053 else if (objfile
== objfile2
)
1056 /* We should have found one of the objfiles before getting here. */
1057 gdb_assert_not_reached ("objfile not found");
1062 gdb_assert_not_reached ("unexpected code path");
1066 /* Select "better" obj_section to keep. We prefer the one that came from
1067 the real object, rather than the one from separate debuginfo.
1068 Most of the time the two sections are exactly identical, but with
1069 prelinking the .rel.dyn section in the real object may have different
1072 static struct obj_section
*
1073 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
1075 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
1076 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
1077 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
1078 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
1079 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
1081 if (a
->objfile
->separate_debug_objfile
!= NULL
)
1086 /* Return 1 if SECTION should be inserted into the section map.
1087 We want to insert only non-overlay and non-TLS section. */
1090 insert_section_p (const struct bfd
*abfd
,
1091 const struct bfd_section
*section
)
1093 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
1095 if (overlay_debugging
&& lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
1096 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
1097 /* This is an overlay section. IN_MEMORY check is needed to avoid
1098 discarding sections from the "system supplied DSO" (aka vdso)
1099 on some Linux systems (e.g. Fedora 11). */
1101 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
1102 /* This is a TLS section. */
1108 /* Filter out overlapping sections where one section came from the real
1109 objfile, and the other from a separate debuginfo file.
1110 Return the size of table after redundant sections have been eliminated. */
1113 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1117 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1119 struct obj_section
*const sect1
= map
[i
];
1120 struct obj_section
*const sect2
= map
[i
+ 1];
1121 const struct objfile
*const objfile1
= sect1
->objfile
;
1122 const struct objfile
*const objfile2
= sect2
->objfile
;
1123 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1124 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1126 if (sect1_addr
== sect2_addr
1127 && (objfile1
->separate_debug_objfile
== objfile2
1128 || objfile2
->separate_debug_objfile
== objfile1
))
1130 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1139 gdb_assert (i
== map_size
- 1);
1143 /* The map should not have shrunk to less than half the original size. */
1144 gdb_assert (map_size
/ 2 <= j
);
1149 /* Filter out overlapping sections, issuing a warning if any are found.
1150 Overlapping sections could really be overlay sections which we didn't
1151 classify as such in insert_section_p, or we could be dealing with a
1155 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1159 for (i
= 0, j
= 0; i
< map_size
- 1; )
1164 for (k
= i
+ 1; k
< map_size
; k
++)
1166 struct obj_section
*const sect1
= map
[i
];
1167 struct obj_section
*const sect2
= map
[k
];
1168 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1169 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1170 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1172 gdb_assert (sect1_addr
<= sect2_addr
);
1174 if (sect1_endaddr
<= sect2_addr
)
1178 /* We have an overlap. Report it. */
1180 struct objfile
*const objf1
= sect1
->objfile
;
1181 struct objfile
*const objf2
= sect2
->objfile
;
1183 const struct bfd
*const abfd1
= objf1
->obfd
;
1184 const struct bfd
*const abfd2
= objf2
->obfd
;
1186 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1187 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1189 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1191 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1193 complaint (&symfile_complaints
,
1194 _("unexpected overlap between:\n"
1195 " (A) section `%s' from `%s' [%s, %s)\n"
1196 " (B) section `%s' from `%s' [%s, %s).\n"
1197 "Will ignore section B"),
1198 bfd_section_name (abfd1
, bfds1
), objf1
->name
,
1199 paddress (gdbarch
, sect1_addr
),
1200 paddress (gdbarch
, sect1_endaddr
),
1201 bfd_section_name (abfd2
, bfds2
), objf2
->name
,
1202 paddress (gdbarch
, sect2_addr
),
1203 paddress (gdbarch
, sect2_endaddr
));
1211 gdb_assert (i
== map_size
- 1);
1219 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1220 TLS, overlay and overlapping sections. */
1223 update_section_map (struct program_space
*pspace
,
1224 struct obj_section
***pmap
, int *pmap_size
)
1226 int alloc_size
, map_size
, i
;
1227 struct obj_section
*s
, **map
;
1228 struct objfile
*objfile
;
1230 gdb_assert (get_objfile_pspace_data (pspace
)->objfiles_changed_p
!= 0);
1236 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1237 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1238 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1241 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1242 if (alloc_size
== 0)
1249 map
= xmalloc (alloc_size
* sizeof (*map
));
1252 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1253 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1254 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1257 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1258 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1259 map_size
= filter_overlapping_sections(map
, map_size
);
1261 if (map_size
< alloc_size
)
1262 /* Some sections were eliminated. Trim excess space. */
1263 map
= xrealloc (map
, map_size
* sizeof (*map
));
1265 gdb_assert (alloc_size
== map_size
);
1268 *pmap_size
= map_size
;
1271 /* Bsearch comparison function. */
1274 bsearch_cmp (const void *key
, const void *elt
)
1276 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1277 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1279 if (pc
< obj_section_addr (section
))
1281 if (pc
< obj_section_endaddr (section
))
1286 /* Returns a section whose range includes PC or NULL if none found. */
1288 struct obj_section
*
1289 find_pc_section (CORE_ADDR pc
)
1291 struct objfile_pspace_info
*pspace_info
;
1292 struct obj_section
*s
, **sp
;
1294 /* Check for mapped overlay section first. */
1295 s
= find_pc_mapped_section (pc
);
1299 pspace_info
= get_objfile_pspace_data (current_program_space
);
1300 if (pspace_info
->objfiles_changed_p
!= 0)
1302 update_section_map (current_program_space
,
1303 &pspace_info
->sections
,
1304 &pspace_info
->num_sections
);
1306 /* Don't need updates to section map until objfiles are added,
1307 removed or relocated. */
1308 pspace_info
->objfiles_changed_p
= 0;
1311 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1312 bsearch be non-NULL. */
1313 if (pspace_info
->sections
== NULL
)
1315 gdb_assert (pspace_info
->num_sections
== 0);
1319 sp
= (struct obj_section
**) bsearch (&pc
,
1320 pspace_info
->sections
,
1321 pspace_info
->num_sections
,
1322 sizeof (*pspace_info
->sections
),
1330 /* In SVR4, we recognize a trampoline by it's section name.
1331 That is, if the pc is in a section named ".plt" then we are in
1335 in_plt_section (CORE_ADDR pc
, char *name
)
1337 struct obj_section
*s
;
1340 s
= find_pc_section (pc
);
1343 && s
->the_bfd_section
->name
!= NULL
1344 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
1349 /* Keep a registry of per-objfile data-pointers required by other GDB
1355 void (*save
) (struct objfile
*, void *);
1356 void (*free
) (struct objfile
*, void *);
1359 struct objfile_data_registration
1361 struct objfile_data
*data
;
1362 struct objfile_data_registration
*next
;
1365 struct objfile_data_registry
1367 struct objfile_data_registration
*registrations
;
1368 unsigned num_registrations
;
1371 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
1373 const struct objfile_data
*
1374 register_objfile_data_with_cleanup (void (*save
) (struct objfile
*, void *),
1375 void (*free
) (struct objfile
*, void *))
1377 struct objfile_data_registration
**curr
;
1379 /* Append new registration. */
1380 for (curr
= &objfile_data_registry
.registrations
;
1381 *curr
!= NULL
; curr
= &(*curr
)->next
);
1383 *curr
= XMALLOC (struct objfile_data_registration
);
1384 (*curr
)->next
= NULL
;
1385 (*curr
)->data
= XMALLOC (struct objfile_data
);
1386 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
1387 (*curr
)->data
->save
= save
;
1388 (*curr
)->data
->free
= free
;
1390 return (*curr
)->data
;
1393 const struct objfile_data
*
1394 register_objfile_data (void)
1396 return register_objfile_data_with_cleanup (NULL
, NULL
);
1400 objfile_alloc_data (struct objfile
*objfile
)
1402 gdb_assert (objfile
->data
== NULL
);
1403 objfile
->num_data
= objfile_data_registry
.num_registrations
;
1404 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
1408 objfile_free_data (struct objfile
*objfile
)
1410 gdb_assert (objfile
->data
!= NULL
);
1411 clear_objfile_data (objfile
);
1412 xfree (objfile
->data
);
1413 objfile
->data
= NULL
;
1417 clear_objfile_data (struct objfile
*objfile
)
1419 struct objfile_data_registration
*registration
;
1422 gdb_assert (objfile
->data
!= NULL
);
1424 /* Process all the save handlers. */
1426 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1427 i
< objfile
->num_data
;
1428 registration
= registration
->next
, i
++)
1429 if (objfile
->data
[i
] != NULL
&& registration
->data
->save
!= NULL
)
1430 registration
->data
->save (objfile
, objfile
->data
[i
]);
1432 /* Now process all the free handlers. */
1434 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1435 i
< objfile
->num_data
;
1436 registration
= registration
->next
, i
++)
1437 if (objfile
->data
[i
] != NULL
&& registration
->data
->free
!= NULL
)
1438 registration
->data
->free (objfile
, objfile
->data
[i
]);
1440 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
1444 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
1447 gdb_assert (data
->index
< objfile
->num_data
);
1448 objfile
->data
[data
->index
] = value
;
1452 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
1454 gdb_assert (data
->index
< objfile
->num_data
);
1455 return objfile
->data
[data
->index
];
1458 /* Set objfiles_changed_p so section map will be rebuilt next time it
1459 is used. Called by reread_symbols. */
1462 objfiles_changed (void)
1464 /* Rebuild section map next time we need it. */
1465 get_objfile_pspace_data (current_program_space
)->objfiles_changed_p
= 1;
1468 /* Close ABFD, and warn if that fails. */
1471 gdb_bfd_close_or_warn (struct bfd
*abfd
)
1474 char *name
= bfd_get_filename (abfd
);
1476 ret
= bfd_close (abfd
);
1479 warning (_("cannot close \"%s\": %s"),
1480 name
, bfd_errmsg (bfd_get_error ()));
1485 /* Add reference to ABFD. Returns ABFD. */
1487 gdb_bfd_ref (struct bfd
*abfd
)
1494 p_refcount
= bfd_usrdata (abfd
);
1496 if (p_refcount
!= NULL
)
1502 p_refcount
= xmalloc (sizeof (*p_refcount
));
1504 bfd_usrdata (abfd
) = p_refcount
;
1509 /* Unreference and possibly close ABFD. */
1511 gdb_bfd_unref (struct bfd
*abfd
)
1519 p_refcount
= bfd_usrdata (abfd
);
1521 /* Valid range for p_refcount: a pointer to int counter, which has a
1522 value of 1 (single owner) or 2 (shared). */
1523 gdb_assert (*p_refcount
== 1 || *p_refcount
== 2);
1526 if (*p_refcount
> 0)
1530 bfd_usrdata (abfd
) = NULL
; /* Paranoia. */
1532 name
= bfd_get_filename (abfd
);
1533 gdb_bfd_close_or_warn (abfd
);
1537 /* Provide a prototype to silence -Wmissing-prototypes. */
1538 extern initialize_file_ftype _initialize_objfiles
;
1541 _initialize_objfiles (void)
1543 objfiles_pspace_data
1544 = register_program_space_data_with_cleanup (objfiles_pspace_data_cleanup
);