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 /* Create the terminating entry of OBJFILE's minimal symbol table.
346 If OBJFILE->msymbols is zero, allocate a single entry from
347 OBJFILE->objfile_obstack; otherwise, just initialize
348 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
350 terminate_minimal_symbol_table (struct objfile *objfile)
352 if (! objfile->msymbols)
353 objfile->msymbols = ((struct minimal_symbol *)
354 obstack_alloc (&objfile->objfile_obstack,
355 sizeof (objfile->msymbols[0])));
358 struct minimal_symbol *m
359 = &objfile->msymbols[objfile->minimal_symbol_count];
361 memset (m, 0, sizeof (*m));
362 /* Don't rely on these enumeration values being 0's. */
363 MSYMBOL_TYPE (m) = mst_unknown;
364 SYMBOL_SET_LANGUAGE (m, language_unknown);
368 /* Iterator on PARENT and every separate debug objfile of PARENT.
369 The usage pattern is:
370 for (objfile = parent;
372 objfile = objfile_separate_debug_iterate (parent, objfile))
377 objfile_separate_debug_iterate (const struct objfile *parent,
378 const struct objfile *objfile)
382 /* If any, return the first child. */
383 res = objfile->separate_debug_objfile;
387 /* Common case where there is no separate debug objfile. */
388 if (objfile == parent)
391 /* Return the brother if any. Note that we don't iterate on brothers of
393 res = objfile->separate_debug_objfile_link;
397 for (res = objfile->separate_debug_objfile_backlink;
399 res = res->separate_debug_objfile_backlink)
401 gdb_assert (res != NULL);
402 if (res->separate_debug_objfile_link)
403 return res->separate_debug_objfile_link;
408 /* Put one object file before a specified on in the global list.
409 This can be used to make sure an object file is destroyed before
410 another when using ALL_OBJFILES_SAFE to free all objfiles. */
412 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
414 struct objfile **objp;
416 unlink_objfile (objfile);
418 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
420 if (*objp == before_this)
422 objfile->next = *objp;
428 internal_error (__FILE__, __LINE__,
429 _("put_objfile_before: before objfile not in list"));
432 /* Put OBJFILE at the front of the list. */
435 objfile_to_front (struct objfile *objfile)
437 struct objfile **objp;
438 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
440 if (*objp == objfile)
442 /* Unhook it from where it is. */
443 *objp = objfile->next;
444 /* Put it in the front. */
445 objfile->next = object_files;
446 object_files = objfile;
452 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
455 It is not a bug, or error, to call this function if OBJFILE is not known
456 to be in the current list. This is done in the case of mapped objfiles,
457 for example, just to ensure that the mapped objfile doesn't appear twice
458 in the list. Since the list is threaded, linking in a mapped objfile
459 twice would create a circular list.
461 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
462 unlinking it, just to ensure that we have completely severed any linkages
463 between the OBJFILE and the list. */
466 unlink_objfile (struct objfile *objfile)
468 struct objfile **objpp;
470 for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
472 if (*objpp == objfile)
474 *objpp = (*objpp)->next;
475 objfile->next = NULL;
480 internal_error (__FILE__, __LINE__,
481 _("unlink_objfile: objfile already unlinked"));
484 /* Add OBJFILE as a separate debug objfile of PARENT. */
487 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
489 gdb_assert (objfile && parent);
491 /* Must not be already in a list. */
492 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
493 gdb_assert (objfile->separate_debug_objfile_link == NULL);
495 objfile->separate_debug_objfile_backlink = parent;
496 objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
497 parent->separate_debug_objfile = objfile;
499 /* Put the separate debug object before the normal one, this is so that
500 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
501 put_objfile_before (objfile, parent);
504 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
508 free_objfile_separate_debug (struct objfile *objfile)
510 struct objfile *child;
512 for (child = objfile->separate_debug_objfile; child;)
514 struct objfile *next_child = child->separate_debug_objfile_link;
515 free_objfile (child);
520 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
521 that as much as possible is allocated on the objfile_obstack
522 so that the memory can be efficiently freed.
524 Things which we do NOT free because they are not in malloc'd memory
525 or not in memory specific to the objfile include:
529 FIXME: If the objfile is using reusable symbol information (via mmalloc),
530 then we need to take into account the fact that more than one process
531 may be using the symbol information at the same time (when mmalloc is
532 extended to support cooperative locking). When more than one process
533 is using the mapped symbol info, we need to be more careful about when
534 we free objects in the reusable area. */
537 free_objfile (struct objfile *objfile)
539 /* Free all separate debug objfiles. */
540 free_objfile_separate_debug (objfile);
542 if (objfile->separate_debug_objfile_backlink)
544 /* We freed the separate debug file, make sure the base objfile
545 doesn't reference it. */
546 struct objfile *child;
548 child = objfile->separate_debug_objfile_backlink->separate_debug_objfile;
550 if (child == objfile)
552 /* OBJFILE is the first child. */
553 objfile->separate_debug_objfile_backlink->separate_debug_objfile =
554 objfile->separate_debug_objfile_link;
558 /* Find OBJFILE in the list. */
561 if (child->separate_debug_objfile_link == objfile)
563 child->separate_debug_objfile_link =
564 objfile->separate_debug_objfile_link;
567 child = child->separate_debug_objfile_link;
573 /* Remove any references to this objfile in the global value
575 preserve_values (objfile);
577 /* It still may reference data modules have associated with the objfile and
578 the symbol file data. */
579 forget_cached_source_info_for_objfile (objfile);
581 /* First do any symbol file specific actions required when we are
582 finished with a particular symbol file. Note that if the objfile
583 is using reusable symbol information (via mmalloc) then each of
584 these routines is responsible for doing the correct thing, either
585 freeing things which are valid only during this particular gdb
586 execution, or leaving them to be reused during the next one. */
588 if (objfile->sf != NULL)
590 (*objfile->sf->sym_finish) (objfile);
593 /* Discard any data modules have associated with the objfile. The function
594 still may reference objfile->obfd. */
595 objfile_free_data (objfile);
597 gdb_bfd_unref (objfile->obfd);
599 /* Remove it from the chain of all objfiles. */
601 unlink_objfile (objfile);
603 if (objfile == symfile_objfile)
604 symfile_objfile = NULL;
606 if (objfile == rt_common_objfile)
607 rt_common_objfile = NULL;
609 /* Before the symbol table code was redone to make it easier to
610 selectively load and remove information particular to a specific
611 linkage unit, gdb used to do these things whenever the monolithic
612 symbol table was blown away. How much still needs to be done
613 is unknown, but we play it safe for now and keep each action until
614 it is shown to be no longer needed. */
616 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
617 for example), so we need to call this here. */
618 clear_pc_function_cache ();
620 /* Clear globals which might have pointed into a removed objfile.
621 FIXME: It's not clear which of these are supposed to persist
622 between expressions and which ought to be reset each time. */
623 expression_context_block = NULL;
624 innermost_block = NULL;
626 /* Check to see if the current_source_symtab belongs to this objfile,
627 and if so, call clear_current_source_symtab_and_line. */
630 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
632 if (cursal.symtab && cursal.symtab->objfile == objfile)
633 clear_current_source_symtab_and_line ();
636 /* The last thing we do is free the objfile struct itself. */
638 xfree (objfile->name);
639 if (objfile->global_psymbols.list)
640 xfree (objfile->global_psymbols.list);
641 if (objfile->static_psymbols.list)
642 xfree (objfile->static_psymbols.list);
643 /* Free the obstacks for non-reusable objfiles. */
644 psymbol_bcache_free (objfile->psymbol_cache);
645 bcache_xfree (objfile->macro_cache);
646 bcache_xfree (objfile->filename_cache);
647 if (objfile->demangled_names_hash)
648 htab_delete (objfile->demangled_names_hash);
649 obstack_free (&objfile->objfile_obstack, 0);
651 /* Rebuild section map next time we need it. */
652 get_objfile_pspace_data (objfile->pspace)->objfiles_changed_p = 1;
658 do_free_objfile_cleanup (void *obj)
664 make_cleanup_free_objfile (struct objfile *obj)
666 return make_cleanup (do_free_objfile_cleanup, obj);
669 /* Free all the object files at once and clean up their users. */
672 free_all_objfiles (void)
674 struct objfile *objfile, *temp;
677 /* Any objfile referencewould become stale. */
678 for (so = master_so_list (); so; so = so->next)
679 gdb_assert (so->objfile == NULL);
681 ALL_OBJFILES_SAFE (objfile, temp)
683 free_objfile (objfile);
685 clear_symtab_users (0);
688 /* A helper function for objfile_relocate1 that relocates a single
692 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
693 struct section_offsets *delta)
695 fixup_symbol_section (sym, objfile);
697 /* The RS6000 code from which this was taken skipped
698 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
699 But I'm leaving out that test, on the theory that
700 they can't possibly pass the tests below. */
701 if ((SYMBOL_CLASS (sym) == LOC_LABEL
702 || SYMBOL_CLASS (sym) == LOC_STATIC)
703 && SYMBOL_SECTION (sym) >= 0)
705 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
709 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
710 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
711 Return non-zero iff any change happened. */
714 objfile_relocate1 (struct objfile *objfile,
715 struct section_offsets *new_offsets)
717 struct obj_section *s;
718 struct section_offsets *delta =
719 ((struct section_offsets *)
720 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
723 int something_changed = 0;
725 for (i = 0; i < objfile->num_sections; ++i)
728 ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
729 if (ANOFFSET (delta, i) != 0)
730 something_changed = 1;
732 if (!something_changed)
735 /* OK, get all the symtabs. */
739 ALL_OBJFILE_SYMTABS (objfile, s)
742 struct blockvector *bv;
745 /* First the line table. */
749 for (i = 0; i < l->nitems; ++i)
750 l->item[i].pc += ANOFFSET (delta, s->block_line_section);
753 /* Don't relocate a shared blockvector more than once. */
757 bv = BLOCKVECTOR (s);
758 if (BLOCKVECTOR_MAP (bv))
759 addrmap_relocate (BLOCKVECTOR_MAP (bv),
760 ANOFFSET (delta, s->block_line_section));
762 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
766 struct dict_iterator iter;
768 b = BLOCKVECTOR_BLOCK (bv, i);
769 BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
770 BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
772 ALL_BLOCK_SYMBOLS (b, iter, sym)
774 relocate_one_symbol (sym, objfile, delta);
780 /* Relocate isolated symbols. */
784 for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
785 relocate_one_symbol (iter, objfile, delta);
788 if (objfile->psymtabs_addrmap)
789 addrmap_relocate (objfile->psymtabs_addrmap,
790 ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
793 objfile->sf->qf->relocate (objfile, new_offsets, delta);
796 struct minimal_symbol *msym;
798 ALL_OBJFILE_MSYMBOLS (objfile, msym)
799 if (SYMBOL_SECTION (msym) >= 0)
800 SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
802 /* Relocating different sections by different amounts may cause the symbols
803 to be out of order. */
804 msymbols_sort (objfile);
806 if (objfile->ei.entry_point_p)
808 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
809 only as a fallback. */
810 struct obj_section *s;
811 s = find_pc_section (objfile->ei.entry_point);
813 objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
815 objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
821 for (i = 0; i < objfile->num_sections; ++i)
822 (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
825 /* Rebuild section map next time we need it. */
826 get_objfile_pspace_data (objfile->pspace)->objfiles_changed_p = 1;
828 /* Update the table in exec_ops, used to read memory. */
829 ALL_OBJFILE_OSECTIONS (objfile, s)
831 int idx = s->the_bfd_section->index;
833 exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
834 obj_section_addr (s));
841 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
842 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
844 The number and ordering of sections does differ between the two objfiles.
845 Only their names match. Also the file offsets will differ (objfile being
846 possibly prelinked but separate_debug_objfile is probably not prelinked) but
847 the in-memory absolute address as specified by NEW_OFFSETS must match both
851 objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)
853 struct objfile *debug_objfile;
856 changed |= objfile_relocate1 (objfile, new_offsets);
858 for (debug_objfile = objfile->separate_debug_objfile;
860 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
862 struct section_addr_info *objfile_addrs;
863 struct section_offsets *new_debug_offsets;
864 struct cleanup *my_cleanups;
866 objfile_addrs = build_section_addr_info_from_objfile (objfile);
867 my_cleanups = make_cleanup (xfree, objfile_addrs);
869 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
870 relative ones must be already created according to debug_objfile. */
872 addr_info_make_relative (objfile_addrs, debug_objfile->obfd);
874 gdb_assert (debug_objfile->num_sections
875 == bfd_count_sections (debug_objfile->obfd));
877 xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
878 make_cleanup (xfree, new_debug_offsets);
879 relative_addr_info_to_section_offsets (new_debug_offsets,
880 debug_objfile->num_sections,
883 changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
885 do_cleanups (my_cleanups);
888 /* Relocate breakpoints as necessary, after things are relocated. */
890 breakpoint_re_set ();
893 /* Return non-zero if OBJFILE has partial symbols. */
896 objfile_has_partial_symbols (struct objfile *objfile)
901 /* If we have not read psymbols, but we have a function capable of reading
902 them, then that is an indication that they are in fact available. Without
903 this function the symbols may have been already read in but they also may
904 not be present in this objfile. */
905 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
906 && objfile->sf->sym_read_psymbols != NULL)
909 return objfile->sf->qf->has_symbols (objfile);
912 /* Return non-zero if OBJFILE has full symbols. */
915 objfile_has_full_symbols (struct objfile *objfile)
917 return objfile->symtabs != NULL;
920 /* Return non-zero if OBJFILE has full or partial symbols, either directly
921 or through a separate debug file. */
924 objfile_has_symbols (struct objfile *objfile)
928 for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
929 if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
935 /* Many places in gdb want to test just to see if we have any partial
936 symbols available. This function returns zero if none are currently
937 available, nonzero otherwise. */
940 have_partial_symbols (void)
946 if (objfile_has_partial_symbols (ofp))
952 /* Many places in gdb want to test just to see if we have any full
953 symbols available. This function returns zero if none are currently
954 available, nonzero otherwise. */
957 have_full_symbols (void)
963 if (objfile_has_full_symbols (ofp))
970 /* This operations deletes all objfile entries that represent solibs that
971 weren't explicitly loaded by the user, via e.g., the add-symbol-file
975 objfile_purge_solibs (void)
977 struct objfile *objf;
978 struct objfile *temp;
980 ALL_OBJFILES_SAFE (objf, temp)
982 /* We assume that the solib package has been purged already, or will
985 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
991 /* Many places in gdb want to test just to see if we have any minimal
992 symbols available. This function returns zero if none are currently
993 available, nonzero otherwise. */
996 have_minimal_symbols (void)
1002 if (ofp->minimal_symbol_count > 0)
1010 /* Qsort comparison function. */
1013 qsort_cmp (const void *a, const void *b)
1015 const struct obj_section *sect1 = *(const struct obj_section **) a;
1016 const struct obj_section *sect2 = *(const struct obj_section **) b;
1017 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1018 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1020 if (sect1_addr < sect2_addr)
1022 else if (sect1_addr > sect2_addr)
1026 /* Sections are at the same address. This could happen if
1027 A) we have an objfile and a separate debuginfo.
1028 B) we are confused, and have added sections without proper relocation,
1029 or something like that. */
1031 const struct objfile *const objfile1 = sect1->objfile;
1032 const struct objfile *const objfile2 = sect2->objfile;
1034 if (objfile1->separate_debug_objfile == objfile2
1035 || objfile2->separate_debug_objfile == objfile1)
1037 /* Case A. The ordering doesn't matter: separate debuginfo files
1038 will be filtered out later. */
1043 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1044 triage. This section could be slow (since we iterate over all
1045 objfiles in each call to qsort_cmp), but this shouldn't happen
1046 very often (GDB is already in a confused state; one hopes this
1047 doesn't happen at all). If you discover that significant time is
1048 spent in the loops below, do 'set complaints 100' and examine the
1049 resulting complaints. */
1051 if (objfile1 == objfile2)
1053 /* Both sections came from the same objfile. We are really confused.
1054 Sort on sequence order of sections within the objfile. */
1056 const struct obj_section *osect;
1058 ALL_OBJFILE_OSECTIONS (objfile1, osect)
1061 else if (osect == sect2)
1064 /* We should have found one of the sections before getting here. */
1065 gdb_assert_not_reached ("section not found");
1069 /* Sort on sequence number of the objfile in the chain. */
1071 const struct objfile *objfile;
1073 ALL_OBJFILES (objfile)
1074 if (objfile == objfile1)
1076 else if (objfile == objfile2)
1079 /* We should have found one of the objfiles before getting here. */
1080 gdb_assert_not_reached ("objfile not found");
1085 gdb_assert_not_reached ("unexpected code path");
1089 /* Select "better" obj_section to keep. We prefer the one that came from
1090 the real object, rather than the one from separate debuginfo.
1091 Most of the time the two sections are exactly identical, but with
1092 prelinking the .rel.dyn section in the real object may have different
1095 static struct obj_section *
1096 preferred_obj_section (struct obj_section *a, struct obj_section *b)
1098 gdb_assert (obj_section_addr (a) == obj_section_addr (b));
1099 gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
1100 || (b->objfile->separate_debug_objfile == a->objfile));
1101 gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
1102 || (b->objfile->separate_debug_objfile_backlink == a->objfile));
1104 if (a->objfile->separate_debug_objfile != NULL)
1109 /* Return 1 if SECTION should be inserted into the section map.
1110 We want to insert only non-overlay and non-TLS section. */
1113 insert_section_p (const struct bfd *abfd,
1114 const struct bfd_section *section)
1116 const bfd_vma lma = bfd_section_lma (abfd, section);
1118 if (lma != 0 && lma != bfd_section_vma (abfd, section)
1119 && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1120 /* This is an overlay section. IN_MEMORY check is needed to avoid
1121 discarding sections from the "system supplied DSO" (aka vdso)
1122 on some Linux systems (e.g. Fedora 11). */
1124 if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1125 /* This is a TLS section. */
1131 /* Filter out overlapping sections where one section came from the real
1132 objfile, and the other from a separate debuginfo file.
1133 Return the size of table after redundant sections have been eliminated. */
1136 filter_debuginfo_sections (struct obj_section **map, int map_size)
1140 for (i = 0, j = 0; i < map_size - 1; i++)
1142 struct obj_section *const sect1 = map[i];
1143 struct obj_section *const sect2 = map[i + 1];
1144 const struct objfile *const objfile1 = sect1->objfile;
1145 const struct objfile *const objfile2 = sect2->objfile;
1146 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1147 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1149 if (sect1_addr == sect2_addr
1150 && (objfile1->separate_debug_objfile == objfile2
1151 || objfile2->separate_debug_objfile == objfile1))
1153 map[j++] = preferred_obj_section (sect1, sect2);
1162 gdb_assert (i == map_size - 1);
1166 /* The map should not have shrunk to less than half the original size. */
1167 gdb_assert (map_size / 2 <= j);
1172 /* Filter out overlapping sections, issuing a warning if any are found.
1173 Overlapping sections could really be overlay sections which we didn't
1174 classify as such in insert_section_p, or we could be dealing with a
1178 filter_overlapping_sections (struct obj_section **map, int map_size)
1182 for (i = 0, j = 0; i < map_size - 1; )
1187 for (k = i + 1; k < map_size; k++)
1189 struct obj_section *const sect1 = map[i];
1190 struct obj_section *const sect2 = map[k];
1191 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1192 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1193 const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1195 gdb_assert (sect1_addr <= sect2_addr);
1197 if (sect1_endaddr <= sect2_addr)
1201 /* We have an overlap. Report it. */
1203 struct objfile *const objf1 = sect1->objfile;
1204 struct objfile *const objf2 = sect2->objfile;
1206 const struct bfd *const abfd1 = objf1->obfd;
1207 const struct bfd *const abfd2 = objf2->obfd;
1209 const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1210 const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1212 const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1214 struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1216 complaint (&symfile_complaints,
1217 _("unexpected overlap between:\n"
1218 " (A) section `%s' from `%s' [%s, %s)\n"
1219 " (B) section `%s' from `%s' [%s, %s).\n"
1220 "Will ignore section B"),
1221 bfd_section_name (abfd1, bfds1), objf1->name,
1222 paddress (gdbarch, sect1_addr),
1223 paddress (gdbarch, sect1_endaddr),
1224 bfd_section_name (abfd2, bfds2), objf2->name,
1225 paddress (gdbarch, sect2_addr),
1226 paddress (gdbarch, sect2_endaddr));
1234 gdb_assert (i == map_size - 1);
1242 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1243 TLS, overlay and overlapping sections. */
1246 update_section_map (struct program_space *pspace,
1247 struct obj_section ***pmap, int *pmap_size)
1249 int alloc_size, map_size, i;
1250 struct obj_section *s, **map;
1251 struct objfile *objfile;
1253 gdb_assert (get_objfile_pspace_data (pspace)->objfiles_changed_p != 0);
1259 ALL_PSPACE_OBJFILES (pspace, objfile)
1260 ALL_OBJFILE_OSECTIONS (objfile, s)
1261 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1264 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1265 if (alloc_size == 0)
1272 map = xmalloc (alloc_size * sizeof (*map));
1275 ALL_PSPACE_OBJFILES (pspace, objfile)
1276 ALL_OBJFILE_OSECTIONS (objfile, s)
1277 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1280 qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1281 map_size = filter_debuginfo_sections(map, alloc_size);
1282 map_size = filter_overlapping_sections(map, map_size);
1284 if (map_size < alloc_size)
1285 /* Some sections were eliminated. Trim excess space. */
1286 map = xrealloc (map, map_size * sizeof (*map));
1288 gdb_assert (alloc_size == map_size);
1291 *pmap_size = map_size;
1294 /* Bsearch comparison function. */
1297 bsearch_cmp (const void *key, const void *elt)
1299 const CORE_ADDR pc = *(CORE_ADDR *) key;
1300 const struct obj_section *section = *(const struct obj_section **) elt;
1302 if (pc < obj_section_addr (section))
1304 if (pc < obj_section_endaddr (section))
1309 /* Returns a section whose range includes PC or NULL if none found. */
1311 struct obj_section *
1312 find_pc_section (CORE_ADDR pc)
1314 struct objfile_pspace_info *pspace_info;
1315 struct obj_section *s, **sp;
1317 /* Check for mapped overlay section first. */
1318 s = find_pc_mapped_section (pc);
1322 pspace_info = get_objfile_pspace_data (current_program_space);
1323 if (pspace_info->objfiles_changed_p != 0)
1325 update_section_map (current_program_space,
1326 &pspace_info->sections,
1327 &pspace_info->num_sections);
1329 /* Don't need updates to section map until objfiles are added,
1330 removed or relocated. */
1331 pspace_info->objfiles_changed_p = 0;
1334 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1335 bsearch be non-NULL. */
1336 if (pspace_info->sections == NULL)
1338 gdb_assert (pspace_info->num_sections == 0);
1342 sp = (struct obj_section **) bsearch (&pc,
1343 pspace_info->sections,
1344 pspace_info->num_sections,
1345 sizeof (*pspace_info->sections),
1353 /* In SVR4, we recognize a trampoline by it's section name.
1354 That is, if the pc is in a section named ".plt" then we are in
1358 in_plt_section (CORE_ADDR pc, char *name)
1360 struct obj_section *s;
1363 s = find_pc_section (pc);
1366 && s->the_bfd_section->name != NULL
1367 && strcmp (s->the_bfd_section->name, ".plt") == 0);
1372 /* Keep a registry of per-objfile data-pointers required by other GDB
1378 void (*save) (struct objfile *, void *);
1379 void (*free) (struct objfile *, void *);
1382 struct objfile_data_registration
1384 struct objfile_data *data;
1385 struct objfile_data_registration *next;
1388 struct objfile_data_registry
1390 struct objfile_data_registration *registrations;
1391 unsigned num_registrations;
1394 static struct objfile_data_registry objfile_data_registry = { NULL, 0 };
1396 const struct objfile_data *
1397 register_objfile_data_with_cleanup (void (*save) (struct objfile *, void *),
1398 void (*free) (struct objfile *, void *))
1400 struct objfile_data_registration **curr;
1402 /* Append new registration. */
1403 for (curr = &objfile_data_registry.registrations;
1404 *curr != NULL; curr = &(*curr)->next);
1406 *curr = XMALLOC (struct objfile_data_registration);
1407 (*curr)->next = NULL;
1408 (*curr)->data = XMALLOC (struct objfile_data);
1409 (*curr)->data->index = objfile_data_registry.num_registrations++;
1410 (*curr)->data->save = save;
1411 (*curr)->data->free = free;
1413 return (*curr)->data;
1416 const struct objfile_data *
1417 register_objfile_data (void)
1419 return register_objfile_data_with_cleanup (NULL, NULL);
1423 objfile_alloc_data (struct objfile *objfile)
1425 gdb_assert (objfile->data == NULL);
1426 objfile->num_data = objfile_data_registry.num_registrations;
1427 objfile->data = XCALLOC (objfile->num_data, void *);
1431 objfile_free_data (struct objfile *objfile)
1433 gdb_assert (objfile->data != NULL);
1434 clear_objfile_data (objfile);
1435 xfree (objfile->data);
1436 objfile->data = NULL;
1440 clear_objfile_data (struct objfile *objfile)
1442 struct objfile_data_registration *registration;
1445 gdb_assert (objfile->data != NULL);
1447 /* Process all the save handlers. */
1449 for (registration = objfile_data_registry.registrations, i = 0;
1450 i < objfile->num_data;
1451 registration = registration->next, i++)
1452 if (objfile->data[i] != NULL && registration->data->save != NULL)
1453 registration->data->save (objfile, objfile->data[i]);
1455 /* Now process all the free handlers. */
1457 for (registration = objfile_data_registry.registrations, i = 0;
1458 i < objfile->num_data;
1459 registration = registration->next, i++)
1460 if (objfile->data[i] != NULL && registration->data->free != NULL)
1461 registration->data->free (objfile, objfile->data[i]);
1463 memset (objfile->data, 0, objfile->num_data * sizeof (void *));
1467 set_objfile_data (struct objfile *objfile, const struct objfile_data *data,
1470 gdb_assert (data->index < objfile->num_data);
1471 objfile->data[data->index] = value;
1475 objfile_data (struct objfile *objfile, const struct objfile_data *data)
1477 gdb_assert (data->index < objfile->num_data);
1478 return objfile->data[data->index];
1481 /* Set objfiles_changed_p so section map will be rebuilt next time it
1482 is used. Called by reread_symbols. */
1485 objfiles_changed (void)
1487 /* Rebuild section map next time we need it. */
1488 get_objfile_pspace_data (current_program_space)->objfiles_changed_p = 1;
1491 /* Close ABFD, and warn if that fails. */
1494 gdb_bfd_close_or_warn (struct bfd *abfd)
1497 char *name = bfd_get_filename (abfd);
1499 ret = bfd_close (abfd);
1502 warning (_("cannot close \"%s\": %s"),
1503 name, bfd_errmsg (bfd_get_error ()));
1508 /* Add reference to ABFD. Returns ABFD. */
1510 gdb_bfd_ref (struct bfd *abfd)
1517 p_refcount = bfd_usrdata (abfd);
1519 if (p_refcount != NULL)
1525 p_refcount = xmalloc (sizeof (*p_refcount));
1527 bfd_usrdata (abfd) = p_refcount;
1532 /* Unreference and possibly close ABFD. */
1534 gdb_bfd_unref (struct bfd *abfd)
1542 p_refcount = bfd_usrdata (abfd);
1544 /* Valid range for p_refcount: a pointer to int counter, which has a
1545 value of 1 (single owner) or 2 (shared). */
1546 gdb_assert (*p_refcount == 1 || *p_refcount == 2);
1549 if (*p_refcount > 0)
1553 bfd_usrdata (abfd) = NULL; /* Paranoia. */
1555 name = bfd_get_filename (abfd);
1556 gdb_bfd_close_or_warn (abfd);
1560 /* Provide a prototype to silence -Wmissing-prototypes. */
1561 extern initialize_file_ftype _initialize_objfiles;
1564 _initialize_objfiles (void)
1566 objfiles_pspace_data
1567 = register_program_space_data_with_cleanup (objfiles_pspace_data_cleanup);