1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992-2015 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 <sys/types.h>
39 #include "gdb_obstack.h"
42 #include "breakpoint.h"
44 #include "dictionary.h"
47 #include "arch-utils.h"
50 #include "complaints.h"
56 /* Keep a registry of per-objfile data-pointers required by other GDB
59 DEFINE_REGISTRY (objfile
, REGISTRY_ACCESS_FIELD
)
61 /* Externally visible variables that are owned by this module.
62 See declarations in objfile.h for more info. */
64 struct objfile_pspace_info
66 struct obj_section
**sections
;
69 /* Nonzero if object files have been added since the section map
71 int new_objfiles_available
;
73 /* Nonzero if the section map MUST be updated before use. */
74 int section_map_dirty
;
76 /* Nonzero if section map updates should be inhibited if possible. */
80 /* Per-program-space data key. */
81 static const struct program_space_data
*objfiles_pspace_data
;
84 objfiles_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
86 struct objfile_pspace_info
*info
= arg
;
88 xfree (info
->sections
);
92 /* Get the current svr4 data. If none is found yet, add it now. This
93 function always returns a valid object. */
95 static struct objfile_pspace_info
*
96 get_objfile_pspace_data (struct program_space
*pspace
)
98 struct objfile_pspace_info
*info
;
100 info
= program_space_data (pspace
, objfiles_pspace_data
);
103 info
= XCNEW (struct objfile_pspace_info
);
104 set_program_space_data (pspace
, objfiles_pspace_data
, info
);
112 /* Per-BFD data key. */
114 static const struct bfd_data
*objfiles_bfd_data
;
116 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
117 NULL, and it already has a per-BFD storage object, use that.
118 Otherwise, allocate a new per-BFD storage object. If ABFD is not
119 NULL, the object is allocated on the BFD; otherwise it is allocated
120 on OBJFILE's obstack. Note that it is not safe to call this
121 multiple times for a given OBJFILE -- it can only be called when
122 allocating or re-initializing OBJFILE. */
124 static struct objfile_per_bfd_storage
*
125 get_objfile_bfd_data (struct objfile
*objfile
, struct bfd
*abfd
)
127 struct objfile_per_bfd_storage
*storage
= NULL
;
130 storage
= bfd_data (abfd
, objfiles_bfd_data
);
134 /* If the object requires gdb to do relocations, we simply fall
135 back to not sharing data across users. These cases are rare
136 enough that this seems reasonable. */
137 if (abfd
!= NULL
&& !gdb_bfd_requires_relocations (abfd
))
140 = ((struct objfile_per_bfd_storage
*)
141 bfd_zalloc (abfd
, sizeof (struct objfile_per_bfd_storage
)));
142 set_bfd_data (abfd
, objfiles_bfd_data
, storage
);
145 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
146 struct objfile_per_bfd_storage
);
148 /* Look up the gdbarch associated with the BFD. */
150 storage
->gdbarch
= gdbarch_from_bfd (abfd
);
152 obstack_init (&storage
->storage_obstack
);
153 storage
->filename_cache
= bcache_xmalloc (NULL
, NULL
);
154 storage
->macro_cache
= bcache_xmalloc (NULL
, NULL
);
155 storage
->language_of_main
= language_unknown
;
164 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage
*storage
)
166 bcache_xfree (storage
->filename_cache
);
167 bcache_xfree (storage
->macro_cache
);
168 if (storage
->demangled_names_hash
)
169 htab_delete (storage
->demangled_names_hash
);
170 obstack_free (&storage
->storage_obstack
, 0);
173 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
174 cleanup function to the BFD registry. */
177 objfile_bfd_data_free (struct bfd
*unused
, void *d
)
179 free_objfile_per_bfd_storage (d
);
182 /* See objfiles.h. */
185 set_objfile_per_bfd (struct objfile
*objfile
)
187 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, objfile
->obfd
);
190 /* Set the objfile's per-BFD notion of the "main" name and
194 set_objfile_main_name (struct objfile
*objfile
,
195 const char *name
, enum language lang
)
197 if (objfile
->per_bfd
->name_of_main
== NULL
198 || strcmp (objfile
->per_bfd
->name_of_main
, name
) != 0)
199 objfile
->per_bfd
->name_of_main
200 = (const char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
, name
,
202 objfile
->per_bfd
->language_of_main
= lang
;
205 /* Helper structure to map blocks to static link properties in hash tables. */
207 struct static_link_htab_entry
209 const struct block
*block
;
210 const struct dynamic_prop
*static_link
;
213 /* Return a hash code for struct static_link_htab_entry *P. */
216 static_link_htab_entry_hash (const void *p
)
218 const struct static_link_htab_entry
*e
219 = (const struct static_link_htab_entry
*) p
;
221 return htab_hash_pointer (e
->block
);
224 /* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
225 mappings for the same block. */
228 static_link_htab_entry_eq (const void *p1
, const void *p2
)
230 const struct static_link_htab_entry
*e1
231 = (const struct static_link_htab_entry
*) p1
;
232 const struct static_link_htab_entry
*e2
233 = (const struct static_link_htab_entry
*) p2
;
235 return e1
->block
== e2
->block
;
238 /* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
239 Must not be called more than once for each BLOCK. */
242 objfile_register_static_link (struct objfile
*objfile
,
243 const struct block
*block
,
244 const struct dynamic_prop
*static_link
)
247 struct static_link_htab_entry lookup_entry
;
248 struct static_link_htab_entry
*entry
;
250 if (objfile
->static_links
== NULL
)
251 objfile
->static_links
= htab_create_alloc
252 (1, &static_link_htab_entry_hash
, static_link_htab_entry_eq
, NULL
,
255 /* Create a slot for the mapping, make sure it's the first mapping for this
256 block and then create the mapping itself. */
257 lookup_entry
.block
= block
;
258 slot
= htab_find_slot (objfile
->static_links
, &lookup_entry
, INSERT
);
259 gdb_assert (*slot
== NULL
);
261 entry
= (struct static_link_htab_entry
*) obstack_alloc
262 (&objfile
->objfile_obstack
, sizeof (*entry
));
263 entry
->block
= block
;
264 entry
->static_link
= static_link
;
265 *slot
= (void *) entry
;
268 /* Look for a static link for BLOCK, which is part of OBJFILE. Return NULL if
271 const struct dynamic_prop
*
272 objfile_lookup_static_link (struct objfile
*objfile
,
273 const struct block
*block
)
275 struct static_link_htab_entry
*entry
;
276 struct static_link_htab_entry lookup_entry
;
278 if (objfile
->static_links
== NULL
)
280 lookup_entry
.block
= block
;
282 = (struct static_link_htab_entry
*) htab_find (objfile
->static_links
,
287 gdb_assert (entry
->block
== block
);
288 return entry
->static_link
;
293 /* Called via bfd_map_over_sections to build up the section table that
294 the objfile references. The objfile contains pointers to the start
295 of the table (objfile->sections) and to the first location after
296 the end of the table (objfile->sections_end). */
299 add_to_objfile_sections_full (struct bfd
*abfd
, struct bfd_section
*asect
,
300 struct objfile
*objfile
, int force
)
302 struct obj_section
*section
;
308 aflag
= bfd_get_section_flags (abfd
, asect
);
309 if (!(aflag
& SEC_ALLOC
))
313 section
= &objfile
->sections
[gdb_bfd_section_index (abfd
, asect
)];
314 section
->objfile
= objfile
;
315 section
->the_bfd_section
= asect
;
316 section
->ovly_mapped
= 0;
320 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
323 add_to_objfile_sections_full (abfd
, asect
, objfilep
, 0);
326 /* Builds a section table for OBJFILE.
328 Note that the OFFSET and OVLY_MAPPED in each table entry are
329 initialized to zero. */
332 build_objfile_section_table (struct objfile
*objfile
)
334 int count
= gdb_bfd_count_sections (objfile
->obfd
);
336 objfile
->sections
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
339 objfile
->sections_end
= (objfile
->sections
+ count
);
340 bfd_map_over_sections (objfile
->obfd
,
341 add_to_objfile_sections
, (void *) objfile
);
343 /* See gdb_bfd_section_index. */
344 add_to_objfile_sections_full (objfile
->obfd
, bfd_com_section_ptr
, objfile
, 1);
345 add_to_objfile_sections_full (objfile
->obfd
, bfd_und_section_ptr
, objfile
, 1);
346 add_to_objfile_sections_full (objfile
->obfd
, bfd_abs_section_ptr
, objfile
, 1);
347 add_to_objfile_sections_full (objfile
->obfd
, bfd_ind_section_ptr
, objfile
, 1);
350 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
351 allocate a new objfile struct, fill it in as best we can, link it
352 into the list of all known objfiles, and return a pointer to the
355 NAME should contain original non-canonicalized filename or other
356 identifier as entered by user. If there is no better source use
357 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
358 NAME content is copied into returned objfile.
360 The FLAGS word contains various bits (OBJF_*) that can be taken as
361 requests for specific operations. Other bits like OBJF_SHARED are
362 simply copied through to the new objfile flags member. */
364 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
365 by jv-lang.c, to create an artificial objfile used to hold
366 information about dynamically-loaded Java classes. Unfortunately,
367 that branch of this function doesn't get tested very frequently, so
368 it's prone to breakage. (E.g. at one time the name was set to NULL
369 in that situation, which broke a loop over all names in the dynamic
370 library loader.) If you change this function, please try to leave
371 things in a consistent state even if abfd is NULL. */
374 allocate_objfile (bfd
*abfd
, const char *name
, int flags
)
376 struct objfile
*objfile
;
379 objfile
= XCNEW (struct objfile
);
380 objfile
->psymbol_cache
= psymbol_bcache_init ();
381 /* We could use obstack_specify_allocation here instead, but
382 gdb_obstack.h specifies the alloc/dealloc functions. */
383 obstack_init (&objfile
->objfile_obstack
);
385 objfile_alloc_data (objfile
);
389 gdb_assert (abfd
== NULL
);
390 gdb_assert ((flags
& OBJF_NOT_FILENAME
) != 0);
391 expanded_name
= xstrdup ("<<anonymous objfile>>");
393 else if ((flags
& OBJF_NOT_FILENAME
) != 0
394 || is_target_filename (name
))
395 expanded_name
= xstrdup (name
);
397 expanded_name
= gdb_abspath (name
);
398 objfile
->original_name
399 = (char *) obstack_copy0 (&objfile
->objfile_obstack
,
401 strlen (expanded_name
));
402 xfree (expanded_name
);
404 /* Update the per-objfile information that comes from the bfd, ensuring
405 that any data that is reference is saved in the per-objfile data
408 objfile
->obfd
= abfd
;
412 objfile
->mtime
= bfd_get_mtime (abfd
);
414 /* Build section table. */
415 build_objfile_section_table (objfile
);
418 objfile
->per_bfd
= get_objfile_bfd_data (objfile
, abfd
);
419 objfile
->pspace
= current_program_space
;
421 terminate_minimal_symbol_table (objfile
);
423 /* Initialize the section indexes for this objfile, so that we can
424 later detect if they are used w/o being properly assigned to. */
426 objfile
->sect_index_text
= -1;
427 objfile
->sect_index_data
= -1;
428 objfile
->sect_index_bss
= -1;
429 objfile
->sect_index_rodata
= -1;
431 /* Add this file onto the tail of the linked list of other such files. */
433 objfile
->next
= NULL
;
434 if (object_files
== NULL
)
435 object_files
= objfile
;
438 struct objfile
*last_one
;
440 for (last_one
= object_files
;
442 last_one
= last_one
->next
);
443 last_one
->next
= objfile
;
446 /* Save passed in flag bits. */
447 objfile
->flags
|= flags
;
449 /* Rebuild section map next time we need it. */
450 get_objfile_pspace_data (objfile
->pspace
)->new_objfiles_available
= 1;
455 /* Retrieve the gdbarch associated with OBJFILE. */
458 get_objfile_arch (const struct objfile
*objfile
)
460 return objfile
->per_bfd
->gdbarch
;
463 /* If there is a valid and known entry point, function fills *ENTRY_P with it
464 and returns non-zero; otherwise it returns zero. */
467 entry_point_address_query (CORE_ADDR
*entry_p
)
469 if (symfile_objfile
== NULL
|| !symfile_objfile
->per_bfd
->ei
.entry_point_p
)
472 *entry_p
= (symfile_objfile
->per_bfd
->ei
.entry_point
473 + ANOFFSET (symfile_objfile
->section_offsets
,
474 symfile_objfile
->per_bfd
->ei
.the_bfd_section_index
));
479 /* Get current entry point address. Call error if it is not known. */
482 entry_point_address (void)
486 if (!entry_point_address_query (&retval
))
487 error (_("Entry point address is not known."));
492 /* Iterator on PARENT and every separate debug objfile of PARENT.
493 The usage pattern is:
494 for (objfile = parent;
496 objfile = objfile_separate_debug_iterate (parent, objfile))
501 objfile_separate_debug_iterate (const struct objfile
*parent
,
502 const struct objfile
*objfile
)
506 /* If any, return the first child. */
507 res
= objfile
->separate_debug_objfile
;
511 /* Common case where there is no separate debug objfile. */
512 if (objfile
== parent
)
515 /* Return the brother if any. Note that we don't iterate on brothers of
517 res
= objfile
->separate_debug_objfile_link
;
521 for (res
= objfile
->separate_debug_objfile_backlink
;
523 res
= res
->separate_debug_objfile_backlink
)
525 gdb_assert (res
!= NULL
);
526 if (res
->separate_debug_objfile_link
)
527 return res
->separate_debug_objfile_link
;
532 /* Put one object file before a specified on in the global list.
533 This can be used to make sure an object file is destroyed before
534 another when using ALL_OBJFILES_SAFE to free all objfiles. */
536 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
538 struct objfile
**objp
;
540 unlink_objfile (objfile
);
542 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
544 if (*objp
== before_this
)
546 objfile
->next
= *objp
;
552 internal_error (__FILE__
, __LINE__
,
553 _("put_objfile_before: before objfile not in list"));
556 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
559 It is not a bug, or error, to call this function if OBJFILE is not known
560 to be in the current list. This is done in the case of mapped objfiles,
561 for example, just to ensure that the mapped objfile doesn't appear twice
562 in the list. Since the list is threaded, linking in a mapped objfile
563 twice would create a circular list.
565 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
566 unlinking it, just to ensure that we have completely severed any linkages
567 between the OBJFILE and the list. */
570 unlink_objfile (struct objfile
*objfile
)
572 struct objfile
**objpp
;
574 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
576 if (*objpp
== objfile
)
578 *objpp
= (*objpp
)->next
;
579 objfile
->next
= NULL
;
584 internal_error (__FILE__
, __LINE__
,
585 _("unlink_objfile: objfile already unlinked"));
588 /* Add OBJFILE as a separate debug objfile of PARENT. */
591 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
593 gdb_assert (objfile
&& parent
);
595 /* Must not be already in a list. */
596 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
597 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
598 gdb_assert (objfile
->separate_debug_objfile
== NULL
);
599 gdb_assert (parent
->separate_debug_objfile_backlink
== NULL
);
600 gdb_assert (parent
->separate_debug_objfile_link
== NULL
);
602 objfile
->separate_debug_objfile_backlink
= parent
;
603 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
604 parent
->separate_debug_objfile
= objfile
;
606 /* Put the separate debug object before the normal one, this is so that
607 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
608 put_objfile_before (objfile
, parent
);
611 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
615 free_objfile_separate_debug (struct objfile
*objfile
)
617 struct objfile
*child
;
619 for (child
= objfile
->separate_debug_objfile
; child
;)
621 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
622 free_objfile (child
);
627 /* Destroy an objfile and all the symtabs and psymtabs under it. */
630 free_objfile (struct objfile
*objfile
)
632 /* First notify observers that this objfile is about to be freed. */
633 observer_notify_free_objfile (objfile
);
635 /* Free all separate debug objfiles. */
636 free_objfile_separate_debug (objfile
);
638 if (objfile
->separate_debug_objfile_backlink
)
640 /* We freed the separate debug file, make sure the base objfile
641 doesn't reference it. */
642 struct objfile
*child
;
644 child
= objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
;
646 if (child
== objfile
)
648 /* OBJFILE is the first child. */
649 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
=
650 objfile
->separate_debug_objfile_link
;
654 /* Find OBJFILE in the list. */
657 if (child
->separate_debug_objfile_link
== objfile
)
659 child
->separate_debug_objfile_link
=
660 objfile
->separate_debug_objfile_link
;
663 child
= child
->separate_debug_objfile_link
;
669 /* Remove any references to this objfile in the global value
671 preserve_values (objfile
);
673 /* It still may reference data modules have associated with the objfile and
674 the symbol file data. */
675 forget_cached_source_info_for_objfile (objfile
);
677 breakpoint_free_objfile (objfile
);
678 btrace_free_objfile (objfile
);
680 /* First do any symbol file specific actions required when we are
681 finished with a particular symbol file. Note that if the objfile
682 is using reusable symbol information (via mmalloc) then each of
683 these routines is responsible for doing the correct thing, either
684 freeing things which are valid only during this particular gdb
685 execution, or leaving them to be reused during the next one. */
687 if (objfile
->sf
!= NULL
)
689 (*objfile
->sf
->sym_finish
) (objfile
);
692 /* Discard any data modules have associated with the objfile. The function
693 still may reference objfile->obfd. */
694 objfile_free_data (objfile
);
697 gdb_bfd_unref (objfile
->obfd
);
699 free_objfile_per_bfd_storage (objfile
->per_bfd
);
701 /* Remove it from the chain of all objfiles. */
703 unlink_objfile (objfile
);
705 if (objfile
== symfile_objfile
)
706 symfile_objfile
= NULL
;
708 /* Before the symbol table code was redone to make it easier to
709 selectively load and remove information particular to a specific
710 linkage unit, gdb used to do these things whenever the monolithic
711 symbol table was blown away. How much still needs to be done
712 is unknown, but we play it safe for now and keep each action until
713 it is shown to be no longer needed. */
715 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
716 for example), so we need to call this here. */
717 clear_pc_function_cache ();
719 /* Clear globals which might have pointed into a removed objfile.
720 FIXME: It's not clear which of these are supposed to persist
721 between expressions and which ought to be reset each time. */
722 expression_context_block
= NULL
;
723 innermost_block
= NULL
;
725 /* Check to see if the current_source_symtab belongs to this objfile,
726 and if so, call clear_current_source_symtab_and_line. */
729 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
731 if (cursal
.symtab
&& SYMTAB_OBJFILE (cursal
.symtab
) == objfile
)
732 clear_current_source_symtab_and_line ();
735 if (objfile
->global_psymbols
.list
)
736 xfree (objfile
->global_psymbols
.list
);
737 if (objfile
->static_psymbols
.list
)
738 xfree (objfile
->static_psymbols
.list
);
739 /* Free the obstacks for non-reusable objfiles. */
740 psymbol_bcache_free (objfile
->psymbol_cache
);
741 obstack_free (&objfile
->objfile_obstack
, 0);
743 /* Rebuild section map next time we need it. */
744 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
746 /* Free the map for static links. There's no need to free static link
747 themselves since they were allocated on the objstack. */
748 if (objfile
->static_links
!= NULL
)
749 htab_delete (objfile
->static_links
);
751 /* The last thing we do is free the objfile struct itself. */
756 do_free_objfile_cleanup (void *obj
)
762 make_cleanup_free_objfile (struct objfile
*obj
)
764 return make_cleanup (do_free_objfile_cleanup
, obj
);
767 /* Free all the object files at once and clean up their users. */
770 free_all_objfiles (void)
772 struct objfile
*objfile
, *temp
;
775 /* Any objfile referencewould become stale. */
776 for (so
= master_so_list (); so
; so
= so
->next
)
777 gdb_assert (so
->objfile
== NULL
);
779 ALL_OBJFILES_SAFE (objfile
, temp
)
781 free_objfile (objfile
);
783 clear_symtab_users (0);
786 /* A helper function for objfile_relocate1 that relocates a single
790 relocate_one_symbol (struct symbol
*sym
, struct objfile
*objfile
,
791 struct section_offsets
*delta
)
793 fixup_symbol_section (sym
, objfile
);
795 /* The RS6000 code from which this was taken skipped
796 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
797 But I'm leaving out that test, on the theory that
798 they can't possibly pass the tests below. */
799 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
800 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
801 && SYMBOL_SECTION (sym
) >= 0)
803 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (delta
, SYMBOL_SECTION (sym
));
807 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
808 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
809 Return non-zero iff any change happened. */
812 objfile_relocate1 (struct objfile
*objfile
,
813 const struct section_offsets
*new_offsets
)
815 struct obj_section
*s
;
816 struct section_offsets
*delta
=
817 ((struct section_offsets
*)
818 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
821 int something_changed
= 0;
823 for (i
= 0; i
< objfile
->num_sections
; ++i
)
826 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
827 if (ANOFFSET (delta
, i
) != 0)
828 something_changed
= 1;
830 if (!something_changed
)
833 /* OK, get all the symtabs. */
835 struct compunit_symtab
*cust
;
838 ALL_OBJFILE_FILETABS (objfile
, cust
, s
)
843 /* First the line table. */
844 l
= SYMTAB_LINETABLE (s
);
847 for (i
= 0; i
< l
->nitems
; ++i
)
848 l
->item
[i
].pc
+= ANOFFSET (delta
,
849 COMPUNIT_BLOCK_LINE_SECTION
854 ALL_OBJFILE_COMPUNITS (objfile
, cust
)
856 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (cust
);
857 int block_line_section
= COMPUNIT_BLOCK_LINE_SECTION (cust
);
859 if (BLOCKVECTOR_MAP (bv
))
860 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
861 ANOFFSET (delta
, block_line_section
));
863 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
867 struct dict_iterator iter
;
869 b
= BLOCKVECTOR_BLOCK (bv
, i
);
870 BLOCK_START (b
) += ANOFFSET (delta
, block_line_section
);
871 BLOCK_END (b
) += ANOFFSET (delta
, block_line_section
);
873 /* We only want to iterate over the local symbols, not any
874 symbols in included symtabs. */
875 ALL_DICT_SYMBOLS (BLOCK_DICT (b
), iter
, sym
)
877 relocate_one_symbol (sym
, objfile
, delta
);
883 /* Relocate isolated symbols. */
887 for (iter
= objfile
->template_symbols
; iter
; iter
= iter
->hash_next
)
888 relocate_one_symbol (iter
, objfile
, delta
);
891 if (objfile
->psymtabs_addrmap
)
892 addrmap_relocate (objfile
->psymtabs_addrmap
,
893 ANOFFSET (delta
, SECT_OFF_TEXT (objfile
)));
896 objfile
->sf
->qf
->relocate (objfile
, new_offsets
, delta
);
901 for (i
= 0; i
< objfile
->num_sections
; ++i
)
902 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
905 /* Rebuild section map next time we need it. */
906 get_objfile_pspace_data (objfile
->pspace
)->section_map_dirty
= 1;
908 /* Update the table in exec_ops, used to read memory. */
909 ALL_OBJFILE_OSECTIONS (objfile
, s
)
911 int idx
= s
- objfile
->sections
;
913 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
914 obj_section_addr (s
));
921 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
922 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
924 The number and ordering of sections does differ between the two objfiles.
925 Only their names match. Also the file offsets will differ (objfile being
926 possibly prelinked but separate_debug_objfile is probably not prelinked) but
927 the in-memory absolute address as specified by NEW_OFFSETS must match both
931 objfile_relocate (struct objfile
*objfile
,
932 const struct section_offsets
*new_offsets
)
934 struct objfile
*debug_objfile
;
937 changed
|= objfile_relocate1 (objfile
, new_offsets
);
939 for (debug_objfile
= objfile
->separate_debug_objfile
;
941 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
943 struct section_addr_info
*objfile_addrs
;
944 struct section_offsets
*new_debug_offsets
;
945 struct cleanup
*my_cleanups
;
947 objfile_addrs
= build_section_addr_info_from_objfile (objfile
);
948 my_cleanups
= make_cleanup (xfree
, objfile_addrs
);
950 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
951 relative ones must be already created according to debug_objfile. */
953 addr_info_make_relative (objfile_addrs
, debug_objfile
->obfd
);
955 gdb_assert (debug_objfile
->num_sections
956 == gdb_bfd_count_sections (debug_objfile
->obfd
));
958 ((struct section_offsets
*)
959 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile
->num_sections
)));
960 make_cleanup (xfree
, new_debug_offsets
);
961 relative_addr_info_to_section_offsets (new_debug_offsets
,
962 debug_objfile
->num_sections
,
965 changed
|= objfile_relocate1 (debug_objfile
, new_debug_offsets
);
967 do_cleanups (my_cleanups
);
970 /* Relocate breakpoints as necessary, after things are relocated. */
972 breakpoint_re_set ();
975 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
977 Return non-zero iff any change happened. */
980 objfile_rebase1 (struct objfile
*objfile
, CORE_ADDR slide
)
982 struct section_offsets
*new_offsets
=
983 ((struct section_offsets
*)
984 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
987 for (i
= 0; i
< objfile
->num_sections
; ++i
)
988 new_offsets
->offsets
[i
] = slide
;
990 return objfile_relocate1 (objfile
, new_offsets
);
993 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
994 SEPARATE_DEBUG_OBJFILEs. */
997 objfile_rebase (struct objfile
*objfile
, CORE_ADDR slide
)
999 struct objfile
*debug_objfile
;
1002 changed
|= objfile_rebase1 (objfile
, slide
);
1004 for (debug_objfile
= objfile
->separate_debug_objfile
;
1006 debug_objfile
= objfile_separate_debug_iterate (objfile
, debug_objfile
))
1007 changed
|= objfile_rebase1 (debug_objfile
, slide
);
1009 /* Relocate breakpoints as necessary, after things are relocated. */
1011 breakpoint_re_set ();
1014 /* Return non-zero if OBJFILE has partial symbols. */
1017 objfile_has_partial_symbols (struct objfile
*objfile
)
1022 /* If we have not read psymbols, but we have a function capable of reading
1023 them, then that is an indication that they are in fact available. Without
1024 this function the symbols may have been already read in but they also may
1025 not be present in this objfile. */
1026 if ((objfile
->flags
& OBJF_PSYMTABS_READ
) == 0
1027 && objfile
->sf
->sym_read_psymbols
!= NULL
)
1030 return objfile
->sf
->qf
->has_symbols (objfile
);
1033 /* Return non-zero if OBJFILE has full symbols. */
1036 objfile_has_full_symbols (struct objfile
*objfile
)
1038 return objfile
->compunit_symtabs
!= NULL
;
1041 /* Return non-zero if OBJFILE has full or partial symbols, either directly
1042 or through a separate debug file. */
1045 objfile_has_symbols (struct objfile
*objfile
)
1049 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
1050 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
1056 /* Many places in gdb want to test just to see if we have any partial
1057 symbols available. This function returns zero if none are currently
1058 available, nonzero otherwise. */
1061 have_partial_symbols (void)
1063 struct objfile
*ofp
;
1067 if (objfile_has_partial_symbols (ofp
))
1073 /* Many places in gdb want to test just to see if we have any full
1074 symbols available. This function returns zero if none are currently
1075 available, nonzero otherwise. */
1078 have_full_symbols (void)
1080 struct objfile
*ofp
;
1084 if (objfile_has_full_symbols (ofp
))
1091 /* This operations deletes all objfile entries that represent solibs that
1092 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1096 objfile_purge_solibs (void)
1098 struct objfile
*objf
;
1099 struct objfile
*temp
;
1101 ALL_OBJFILES_SAFE (objf
, temp
)
1103 /* We assume that the solib package has been purged already, or will
1106 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
1107 free_objfile (objf
);
1112 /* Many places in gdb want to test just to see if we have any minimal
1113 symbols available. This function returns zero if none are currently
1114 available, nonzero otherwise. */
1117 have_minimal_symbols (void)
1119 struct objfile
*ofp
;
1123 if (ofp
->per_bfd
->minimal_symbol_count
> 0)
1131 /* Qsort comparison function. */
1134 qsort_cmp (const void *a
, const void *b
)
1136 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
1137 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
1138 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1139 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1141 if (sect1_addr
< sect2_addr
)
1143 else if (sect1_addr
> sect2_addr
)
1147 /* Sections are at the same address. This could happen if
1148 A) we have an objfile and a separate debuginfo.
1149 B) we are confused, and have added sections without proper relocation,
1150 or something like that. */
1152 const struct objfile
*const objfile1
= sect1
->objfile
;
1153 const struct objfile
*const objfile2
= sect2
->objfile
;
1155 if (objfile1
->separate_debug_objfile
== objfile2
1156 || objfile2
->separate_debug_objfile
== objfile1
)
1158 /* Case A. The ordering doesn't matter: separate debuginfo files
1159 will be filtered out later. */
1164 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1165 triage. This section could be slow (since we iterate over all
1166 objfiles in each call to qsort_cmp), but this shouldn't happen
1167 very often (GDB is already in a confused state; one hopes this
1168 doesn't happen at all). If you discover that significant time is
1169 spent in the loops below, do 'set complaints 100' and examine the
1170 resulting complaints. */
1172 if (objfile1
== objfile2
)
1174 /* Both sections came from the same objfile. We are really confused.
1175 Sort on sequence order of sections within the objfile. */
1177 const struct obj_section
*osect
;
1179 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1182 else if (osect
== sect2
)
1185 /* We should have found one of the sections before getting here. */
1186 gdb_assert_not_reached ("section not found");
1190 /* Sort on sequence number of the objfile in the chain. */
1192 const struct objfile
*objfile
;
1194 ALL_OBJFILES (objfile
)
1195 if (objfile
== objfile1
)
1197 else if (objfile
== objfile2
)
1200 /* We should have found one of the objfiles before getting here. */
1201 gdb_assert_not_reached ("objfile not found");
1206 gdb_assert_not_reached ("unexpected code path");
1210 /* Select "better" obj_section to keep. We prefer the one that came from
1211 the real object, rather than the one from separate debuginfo.
1212 Most of the time the two sections are exactly identical, but with
1213 prelinking the .rel.dyn section in the real object may have different
1216 static struct obj_section
*
1217 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
1219 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
1220 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
1221 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
1222 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
1223 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
1225 if (a
->objfile
->separate_debug_objfile
!= NULL
)
1230 /* Return 1 if SECTION should be inserted into the section map.
1231 We want to insert only non-overlay and non-TLS section. */
1234 insert_section_p (const struct bfd
*abfd
,
1235 const struct bfd_section
*section
)
1237 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
1239 if (overlay_debugging
&& lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
1240 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
1241 /* This is an overlay section. IN_MEMORY check is needed to avoid
1242 discarding sections from the "system supplied DSO" (aka vdso)
1243 on some Linux systems (e.g. Fedora 11). */
1245 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
1246 /* This is a TLS section. */
1252 /* Filter out overlapping sections where one section came from the real
1253 objfile, and the other from a separate debuginfo file.
1254 Return the size of table after redundant sections have been eliminated. */
1257 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1261 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1263 struct obj_section
*const sect1
= map
[i
];
1264 struct obj_section
*const sect2
= map
[i
+ 1];
1265 const struct objfile
*const objfile1
= sect1
->objfile
;
1266 const struct objfile
*const objfile2
= sect2
->objfile
;
1267 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1268 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1270 if (sect1_addr
== sect2_addr
1271 && (objfile1
->separate_debug_objfile
== objfile2
1272 || objfile2
->separate_debug_objfile
== objfile1
))
1274 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1283 gdb_assert (i
== map_size
- 1);
1287 /* The map should not have shrunk to less than half the original size. */
1288 gdb_assert (map_size
/ 2 <= j
);
1293 /* Filter out overlapping sections, issuing a warning if any are found.
1294 Overlapping sections could really be overlay sections which we didn't
1295 classify as such in insert_section_p, or we could be dealing with a
1299 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1303 for (i
= 0, j
= 0; i
< map_size
- 1; )
1308 for (k
= i
+ 1; k
< map_size
; k
++)
1310 struct obj_section
*const sect1
= map
[i
];
1311 struct obj_section
*const sect2
= map
[k
];
1312 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1313 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1314 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1316 gdb_assert (sect1_addr
<= sect2_addr
);
1318 if (sect1_endaddr
<= sect2_addr
)
1322 /* We have an overlap. Report it. */
1324 struct objfile
*const objf1
= sect1
->objfile
;
1325 struct objfile
*const objf2
= sect2
->objfile
;
1327 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1328 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1330 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1332 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1334 complaint (&symfile_complaints
,
1335 _("unexpected overlap between:\n"
1336 " (A) section `%s' from `%s' [%s, %s)\n"
1337 " (B) section `%s' from `%s' [%s, %s).\n"
1338 "Will ignore section B"),
1339 bfd_section_name (abfd1
, bfds1
), objfile_name (objf1
),
1340 paddress (gdbarch
, sect1_addr
),
1341 paddress (gdbarch
, sect1_endaddr
),
1342 bfd_section_name (abfd2
, bfds2
), objfile_name (objf2
),
1343 paddress (gdbarch
, sect2_addr
),
1344 paddress (gdbarch
, sect2_endaddr
));
1352 gdb_assert (i
== map_size
- 1);
1360 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1361 TLS, overlay and overlapping sections. */
1364 update_section_map (struct program_space
*pspace
,
1365 struct obj_section
***pmap
, int *pmap_size
)
1367 struct objfile_pspace_info
*pspace_info
;
1368 int alloc_size
, map_size
, i
;
1369 struct obj_section
*s
, **map
;
1370 struct objfile
*objfile
;
1372 pspace_info
= get_objfile_pspace_data (pspace
);
1373 gdb_assert (pspace_info
->section_map_dirty
!= 0
1374 || pspace_info
->new_objfiles_available
!= 0);
1380 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1381 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1382 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1385 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1386 if (alloc_size
== 0)
1393 map
= XNEWVEC (struct obj_section
*, alloc_size
);
1396 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1397 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1398 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1401 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1402 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1403 map_size
= filter_overlapping_sections(map
, map_size
);
1405 if (map_size
< alloc_size
)
1406 /* Some sections were eliminated. Trim excess space. */
1407 map
= XRESIZEVEC (struct obj_section
*, map
, map_size
);
1409 gdb_assert (alloc_size
== map_size
);
1412 *pmap_size
= map_size
;
1415 /* Bsearch comparison function. */
1418 bsearch_cmp (const void *key
, const void *elt
)
1420 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1421 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1423 if (pc
< obj_section_addr (section
))
1425 if (pc
< obj_section_endaddr (section
))
1430 /* Returns a section whose range includes PC or NULL if none found. */
1432 struct obj_section
*
1433 find_pc_section (CORE_ADDR pc
)
1435 struct objfile_pspace_info
*pspace_info
;
1436 struct obj_section
*s
, **sp
;
1438 /* Check for mapped overlay section first. */
1439 s
= find_pc_mapped_section (pc
);
1443 pspace_info
= get_objfile_pspace_data (current_program_space
);
1444 if (pspace_info
->section_map_dirty
1445 || (pspace_info
->new_objfiles_available
1446 && !pspace_info
->inhibit_updates
))
1448 update_section_map (current_program_space
,
1449 &pspace_info
->sections
,
1450 &pspace_info
->num_sections
);
1452 /* Don't need updates to section map until objfiles are added,
1453 removed or relocated. */
1454 pspace_info
->new_objfiles_available
= 0;
1455 pspace_info
->section_map_dirty
= 0;
1458 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1459 bsearch be non-NULL. */
1460 if (pspace_info
->sections
== NULL
)
1462 gdb_assert (pspace_info
->num_sections
== 0);
1466 sp
= (struct obj_section
**) bsearch (&pc
,
1467 pspace_info
->sections
,
1468 pspace_info
->num_sections
,
1469 sizeof (*pspace_info
->sections
),
1477 /* Return non-zero if PC is in a section called NAME. */
1480 pc_in_section (CORE_ADDR pc
, char *name
)
1482 struct obj_section
*s
;
1485 s
= find_pc_section (pc
);
1488 && s
->the_bfd_section
->name
!= NULL
1489 && strcmp (s
->the_bfd_section
->name
, name
) == 0);
1494 /* Set section_map_dirty so section map will be rebuilt next time it
1495 is used. Called by reread_symbols. */
1498 objfiles_changed (void)
1500 /* Rebuild section map next time we need it. */
1501 get_objfile_pspace_data (current_program_space
)->section_map_dirty
= 1;
1504 /* See comments in objfiles.h. */
1507 inhibit_section_map_updates (struct program_space
*pspace
)
1509 get_objfile_pspace_data (pspace
)->inhibit_updates
= 1;
1512 /* See comments in objfiles.h. */
1515 resume_section_map_updates (struct program_space
*pspace
)
1517 get_objfile_pspace_data (pspace
)->inhibit_updates
= 0;
1520 /* See comments in objfiles.h. */
1523 resume_section_map_updates_cleanup (void *arg
)
1525 resume_section_map_updates (arg
);
1528 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1532 is_addr_in_objfile (CORE_ADDR addr
, const struct objfile
*objfile
)
1534 struct obj_section
*osect
;
1536 if (objfile
== NULL
)
1539 ALL_OBJFILE_OSECTIONS (objfile
, osect
)
1541 if (section_is_overlay (osect
) && !section_is_mapped (osect
))
1544 if (obj_section_addr (osect
) <= addr
1545 && addr
< obj_section_endaddr (osect
))
1552 shared_objfile_contains_address_p (struct program_space
*pspace
,
1555 struct objfile
*objfile
;
1557 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1559 if ((objfile
->flags
& OBJF_SHARED
) != 0
1560 && is_addr_in_objfile (address
, objfile
))
1567 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1568 gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
1569 searching the objfiles in the order they are stored internally,
1570 ignoring CURRENT_OBJFILE.
1572 On most platorms, it should be close enough to doing the best
1573 we can without some knowledge specific to the architecture. */
1576 default_iterate_over_objfiles_in_search_order
1577 (struct gdbarch
*gdbarch
,
1578 iterate_over_objfiles_in_search_order_cb_ftype
*cb
,
1579 void *cb_data
, struct objfile
*current_objfile
)
1582 struct objfile
*objfile
;
1584 ALL_OBJFILES (objfile
)
1586 stop
= cb (objfile
, cb_data
);
1592 /* See objfiles.h. */
1595 objfile_name (const struct objfile
*objfile
)
1597 if (objfile
->obfd
!= NULL
)
1598 return bfd_get_filename (objfile
->obfd
);
1600 return objfile
->original_name
;
1603 /* See objfiles.h. */
1606 objfile_filename (const struct objfile
*objfile
)
1608 if (objfile
->obfd
!= NULL
)
1609 return bfd_get_filename (objfile
->obfd
);
1614 /* See objfiles.h. */
1617 objfile_debug_name (const struct objfile
*objfile
)
1619 return lbasename (objfile
->original_name
);
1622 /* See objfiles.h. */
1625 objfile_flavour_name (struct objfile
*objfile
)
1627 if (objfile
->obfd
!= NULL
)
1628 return bfd_flavour_name (bfd_get_flavour (objfile
->obfd
));
1632 /* Provide a prototype to silence -Wmissing-prototypes. */
1633 extern initialize_file_ftype _initialize_objfiles
;
1636 _initialize_objfiles (void)
1638 objfiles_pspace_data
1639 = register_program_space_data_with_cleanup (NULL
,
1640 objfiles_pspace_data_cleanup
);
1642 objfiles_bfd_data
= register_bfd_data_with_cleanup (NULL
,
1643 objfile_bfd_data_free
);