1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 Contributed by Cygnus Support, using pieces from other GDB modules.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* This file contains support routines for creating, manipulating, and
24 destroying objfile structures. */
27 #include "bfd.h" /* Binary File Description */
31 #include "gdb-stabs.h"
34 #include "mdebugread.h"
35 #include "expression.h"
36 #include "parser-defs.h"
38 #include "gdb_assert.h"
39 #include <sys/types.h>
42 #include "gdb_obstack.h"
43 #include "gdb_string.h"
46 #include "breakpoint.h"
48 #include "dictionary.h"
51 #include "arch-utils.h"
54 #include "complaints.h"
58 /* Prototypes for local functions */
60 static void objfile_alloc_data (struct objfile
*objfile
);
61 static void objfile_free_data (struct objfile
*objfile
);
63 /* Externally visible variables that are owned by this module.
64 See declarations in objfile.h for more info. */
66 struct objfile
*current_objfile
; /* For symbol file being read in */
67 struct objfile
*rt_common_objfile
; /* For runtime common symbols */
69 struct objfile_pspace_info
71 int objfiles_changed_p
;
72 struct obj_section
**sections
;
76 /* Per-program-space data key. */
77 static const struct program_space_data
*objfiles_pspace_data
;
80 objfiles_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
82 struct objfile_pspace_info
*info
;
84 info
= program_space_data (pspace
, objfiles_pspace_data
);
87 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
= XZALLOC (struct objfile_pspace_info
);
104 set_program_space_data (pspace
, objfiles_pspace_data
, info
);
110 /* Records whether any objfiles appeared or disappeared since we last updated
111 address to obj section map. */
113 /* Locate all mappable sections of a BFD file.
114 objfile_p_char is a char * to get it through
115 bfd_map_over_sections; we cast it back to its proper type. */
117 /* Called via bfd_map_over_sections to build up the section table that
118 the objfile references. The objfile contains pointers to the start
119 of the table (objfile->sections) and to the first location after
120 the end of the table (objfile->sections_end). */
123 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
124 void *objfile_p_char
)
126 struct objfile
*objfile
= (struct objfile
*) objfile_p_char
;
127 struct obj_section section
;
130 aflag
= bfd_get_section_flags (abfd
, asect
);
132 if (!(aflag
& SEC_ALLOC
))
135 if (0 == bfd_section_size (abfd
, asect
))
137 section
.objfile
= objfile
;
138 section
.the_bfd_section
= asect
;
139 section
.ovly_mapped
= 0;
140 obstack_grow (&objfile
->objfile_obstack
, (char *) §ion
, sizeof (section
));
141 objfile
->sections_end
142 = (struct obj_section
*) (((size_t) objfile
->sections_end
) + 1);
145 /* Builds a section table for OBJFILE.
146 Returns 0 if OK, 1 on error (in which case bfd_error contains the
149 Note that while we are building the table, which goes into the
150 psymbol obstack, we hijack the sections_end pointer to instead hold
151 a count of the number of sections. When bfd_map_over_sections
152 returns, this count is used to compute the pointer to the end of
153 the sections table, which then overwrites the count.
155 Also note that the OFFSET and OVLY_MAPPED in each table entry
156 are initialized to zero.
158 Also note that if anything else writes to the psymbol obstack while
159 we are building the table, we're pretty much hosed. */
162 build_objfile_section_table (struct objfile
*objfile
)
164 /* objfile->sections can be already set when reading a mapped symbol
165 file. I believe that we do need to rebuild the section table in
166 this case (we rebuild other things derived from the bfd), but we
167 can't free the old one (it's in the objfile_obstack). So we just
168 waste some memory. */
170 objfile
->sections_end
= 0;
171 bfd_map_over_sections (objfile
->obfd
,
172 add_to_objfile_sections
, (void *) objfile
);
173 objfile
->sections
= obstack_finish (&objfile
->objfile_obstack
);
174 objfile
->sections_end
= objfile
->sections
+ (size_t) objfile
->sections_end
;
178 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
179 allocate a new objfile struct, fill it in as best we can, link it
180 into the list of all known objfiles, and return a pointer to the
183 The FLAGS word contains various bits (OBJF_*) that can be taken as
184 requests for specific operations. Other bits like OBJF_SHARED are
185 simply copied through to the new objfile flags member. */
187 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
188 by jv-lang.c, to create an artificial objfile used to hold
189 information about dynamically-loaded Java classes. Unfortunately,
190 that branch of this function doesn't get tested very frequently, so
191 it's prone to breakage. (E.g. at one time the name was set to NULL
192 in that situation, which broke a loop over all names in the dynamic
193 library loader.) If you change this function, please try to leave
194 things in a consistent state even if abfd is NULL. */
197 allocate_objfile (bfd
*abfd
, int flags
)
199 struct objfile
*objfile
;
201 objfile
= (struct objfile
*) xzalloc (sizeof (struct objfile
));
202 objfile
->psymbol_cache
= bcache_xmalloc ();
203 objfile
->macro_cache
= bcache_xmalloc ();
204 objfile
->filename_cache
= bcache_xmalloc ();
205 /* We could use obstack_specify_allocation here instead, but
206 gdb_obstack.h specifies the alloc/dealloc functions. */
207 obstack_init (&objfile
->objfile_obstack
);
208 terminate_minimal_symbol_table (objfile
);
210 objfile_alloc_data (objfile
);
212 /* Update the per-objfile information that comes from the bfd, ensuring
213 that any data that is reference is saved in the per-objfile data
216 objfile
->obfd
= gdb_bfd_ref (abfd
);
217 if (objfile
->name
!= NULL
)
219 xfree (objfile
->name
);
223 /* Look up the gdbarch associated with the BFD. */
224 objfile
->gdbarch
= gdbarch_from_bfd (abfd
);
226 objfile
->name
= xstrdup (bfd_get_filename (abfd
));
227 objfile
->mtime
= bfd_get_mtime (abfd
);
229 /* Build section table. */
231 if (build_objfile_section_table (objfile
))
233 error (_("Can't find the file sections in `%s': %s"),
234 objfile
->name
, bfd_errmsg (bfd_get_error ()));
239 objfile
->name
= xstrdup ("<<anonymous objfile>>");
242 objfile
->pspace
= current_program_space
;
244 /* Initialize the section indexes for this objfile, so that we can
245 later detect if they are used w/o being properly assigned to. */
247 objfile
->sect_index_text
= -1;
248 objfile
->sect_index_data
= -1;
249 objfile
->sect_index_bss
= -1;
250 objfile
->sect_index_rodata
= -1;
252 /* We don't yet have a C++-specific namespace symtab. */
254 objfile
->cp_namespace_symtab
= NULL
;
256 /* Add this file onto the tail of the linked list of other such files. */
258 objfile
->next
= NULL
;
259 if (object_files
== NULL
)
260 object_files
= objfile
;
263 struct objfile
*last_one
;
265 for (last_one
= object_files
;
267 last_one
= last_one
->next
);
268 last_one
->next
= objfile
;
271 /* Save passed in flag bits. */
272 objfile
->flags
|= flags
;
274 /* Rebuild section map next time we need it. */
275 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
280 /* Retrieve the gdbarch associated with OBJFILE. */
282 get_objfile_arch (struct objfile
*objfile
)
284 return objfile
->gdbarch
;
287 /* Initialize entry point information for this objfile. */
290 init_entry_point_info (struct objfile
*objfile
)
292 /* Save startup file's range of PC addresses to help blockframe.c
293 decide where the bottom of the stack is. */
295 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
297 /* Executable file -- record its entry point so we'll recognize
298 the startup file because it contains the entry point. */
299 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
300 objfile
->ei
.entry_point_p
= 1;
302 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
303 && bfd_get_start_address (objfile
->obfd
) != 0)
305 /* Some shared libraries may have entry points set and be
306 runnable. There's no clear way to indicate this, so just check
307 for values other than zero. */
308 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
309 objfile
->ei
.entry_point_p
= 1;
313 /* Examination of non-executable.o files. Short-circuit this stuff. */
314 objfile
->ei
.entry_point_p
= 0;
318 /* If there is a valid and known entry point, function fills *ENTRY_P with it
319 and returns non-zero; otherwise it returns zero. */
322 entry_point_address_query (CORE_ADDR
*entry_p
)
324 struct gdbarch
*gdbarch
;
325 CORE_ADDR entry_point
;
327 if (symfile_objfile
== NULL
|| !symfile_objfile
->ei
.entry_point_p
)
330 gdbarch
= get_objfile_arch (symfile_objfile
);
332 entry_point
= symfile_objfile
->ei
.entry_point
;
334 /* Make certain that the address points at real code, and not a
335 function descriptor. */
336 entry_point
= gdbarch_convert_from_func_ptr_addr (gdbarch
, entry_point
,
339 /* Remove any ISA markers, so that this matches entries in the
341 entry_point
= gdbarch_addr_bits_remove (gdbarch
, entry_point
);
343 *entry_p
= entry_point
;
347 /* Get current entry point address. Call error if it is not known. */
350 entry_point_address (void)
354 if (!entry_point_address_query (&retval
))
355 error (_("Entry point address is not known."));
360 /* Create the terminating entry of OBJFILE's minimal symbol table.
361 If OBJFILE->msymbols is zero, allocate a single entry from
362 OBJFILE->objfile_obstack; otherwise, just initialize
363 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
365 terminate_minimal_symbol_table (struct objfile
*objfile
)
367 if (! objfile
->msymbols
)
368 objfile
->msymbols
= ((struct minimal_symbol
*)
369 obstack_alloc (&objfile
->objfile_obstack
,
370 sizeof (objfile
->msymbols
[0])));
373 struct minimal_symbol
*m
374 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
376 memset (m
, 0, sizeof (*m
));
377 /* Don't rely on these enumeration values being 0's. */
378 MSYMBOL_TYPE (m
) = mst_unknown
;
379 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
383 /* Iterator on PARENT and every separate debug objfile of PARENT.
384 The usage pattern is:
385 for (objfile = parent;
387 objfile = objfile_separate_debug_iterate (parent, objfile))
392 objfile_separate_debug_iterate (const struct objfile
*parent
,
393 const struct objfile
*objfile
)
397 /* If any, return the first child. */
398 res
= objfile
->separate_debug_objfile
;
402 /* Common case where there is no separate debug objfile. */
403 if (objfile
== parent
)
406 /* Return the brother if any. Note that we don't iterate on brothers of
408 res
= objfile
->separate_debug_objfile_link
;
412 for (res
= objfile
->separate_debug_objfile_backlink
;
414 res
= res
->separate_debug_objfile_backlink
)
416 gdb_assert (res
!= NULL
);
417 if (res
->separate_debug_objfile_link
)
418 return res
->separate_debug_objfile_link
;
423 /* Put one object file before a specified on in the global list.
424 This can be used to make sure an object file is destroyed before
425 another when using ALL_OBJFILES_SAFE to free all objfiles. */
427 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
429 struct objfile
**objp
;
431 unlink_objfile (objfile
);
433 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
435 if (*objp
== before_this
)
437 objfile
->next
= *objp
;
443 internal_error (__FILE__
, __LINE__
,
444 _("put_objfile_before: before objfile not in list"));
447 /* Put OBJFILE at the front of the list. */
450 objfile_to_front (struct objfile
*objfile
)
452 struct objfile
**objp
;
453 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
455 if (*objp
== objfile
)
457 /* Unhook it from where it is. */
458 *objp
= objfile
->next
;
459 /* Put it in the front. */
460 objfile
->next
= object_files
;
461 object_files
= objfile
;
467 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
470 It is not a bug, or error, to call this function if OBJFILE is not known
471 to be in the current list. This is done in the case of mapped objfiles,
472 for example, just to ensure that the mapped objfile doesn't appear twice
473 in the list. Since the list is threaded, linking in a mapped objfile
474 twice would create a circular list.
476 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
477 unlinking it, just to ensure that we have completely severed any linkages
478 between the OBJFILE and the list. */
481 unlink_objfile (struct objfile
*objfile
)
483 struct objfile
**objpp
;
485 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
487 if (*objpp
== objfile
)
489 *objpp
= (*objpp
)->next
;
490 objfile
->next
= NULL
;
495 internal_error (__FILE__
, __LINE__
,
496 _("unlink_objfile: objfile already unlinked"));
499 /* Add OBJFILE as a separate debug objfile of PARENT. */
502 add_separate_debug_objfile (struct objfile
*objfile
, struct objfile
*parent
)
504 gdb_assert (objfile
&& parent
);
506 /* Must not be already in a list. */
507 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
508 gdb_assert (objfile
->separate_debug_objfile_link
== NULL
);
510 objfile
->separate_debug_objfile_backlink
= parent
;
511 objfile
->separate_debug_objfile_link
= parent
->separate_debug_objfile
;
512 parent
->separate_debug_objfile
= objfile
;
514 /* Put the separate debug object before the normal one, this is so that
515 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
516 put_objfile_before (objfile
, parent
);
519 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
523 free_objfile_separate_debug (struct objfile
*objfile
)
525 struct objfile
*child
;
527 for (child
= objfile
->separate_debug_objfile
; child
;)
529 struct objfile
*next_child
= child
->separate_debug_objfile_link
;
530 free_objfile (child
);
535 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
536 that as much as possible is allocated on the objfile_obstack
537 so that the memory can be efficiently freed.
539 Things which we do NOT free because they are not in malloc'd memory
540 or not in memory specific to the objfile include:
544 FIXME: If the objfile is using reusable symbol information (via mmalloc),
545 then we need to take into account the fact that more than one process
546 may be using the symbol information at the same time (when mmalloc is
547 extended to support cooperative locking). When more than one process
548 is using the mapped symbol info, we need to be more careful about when
549 we free objects in the reusable area. */
552 free_objfile (struct objfile
*objfile
)
554 /* Free all separate debug objfiles. */
555 free_objfile_separate_debug (objfile
);
557 if (objfile
->separate_debug_objfile_backlink
)
559 /* We freed the separate debug file, make sure the base objfile
560 doesn't reference it. */
561 struct objfile
*child
;
563 child
= objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
;
565 if (child
== objfile
)
567 /* OBJFILE is the first child. */
568 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
=
569 objfile
->separate_debug_objfile_link
;
573 /* Find OBJFILE in the list. */
576 if (child
->separate_debug_objfile_link
== objfile
)
578 child
->separate_debug_objfile_link
=
579 objfile
->separate_debug_objfile_link
;
582 child
= child
->separate_debug_objfile_link
;
588 /* Remove any references to this objfile in the global value
590 preserve_values (objfile
);
592 /* First do any symbol file specific actions required when we are
593 finished with a particular symbol file. Note that if the objfile
594 is using reusable symbol information (via mmalloc) then each of
595 these routines is responsible for doing the correct thing, either
596 freeing things which are valid only during this particular gdb
597 execution, or leaving them to be reused during the next one. */
599 if (objfile
->sf
!= NULL
)
601 (*objfile
->sf
->sym_finish
) (objfile
);
604 /* Discard any data modules have associated with the objfile. */
605 objfile_free_data (objfile
);
607 gdb_bfd_unref (objfile
->obfd
);
609 /* Remove it from the chain of all objfiles. */
611 unlink_objfile (objfile
);
613 if (objfile
== symfile_objfile
)
614 symfile_objfile
= NULL
;
616 if (objfile
== rt_common_objfile
)
617 rt_common_objfile
= NULL
;
619 /* Before the symbol table code was redone to make it easier to
620 selectively load and remove information particular to a specific
621 linkage unit, gdb used to do these things whenever the monolithic
622 symbol table was blown away. How much still needs to be done
623 is unknown, but we play it safe for now and keep each action until
624 it is shown to be no longer needed. */
626 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
627 for example), so we need to call this here. */
628 clear_pc_function_cache ();
630 /* Clear globals which might have pointed into a removed objfile.
631 FIXME: It's not clear which of these are supposed to persist
632 between expressions and which ought to be reset each time. */
633 expression_context_block
= NULL
;
634 innermost_block
= NULL
;
636 /* Check to see if the current_source_symtab belongs to this objfile,
637 and if so, call clear_current_source_symtab_and_line. */
640 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
643 ALL_OBJFILE_SYMTABS (objfile
, s
)
645 if (s
== cursal
.symtab
)
646 clear_current_source_symtab_and_line ();
650 /* The last thing we do is free the objfile struct itself. */
652 if (objfile
->name
!= NULL
)
654 xfree (objfile
->name
);
656 if (objfile
->global_psymbols
.list
)
657 xfree (objfile
->global_psymbols
.list
);
658 if (objfile
->static_psymbols
.list
)
659 xfree (objfile
->static_psymbols
.list
);
660 /* Free the obstacks for non-reusable objfiles */
661 bcache_xfree (objfile
->psymbol_cache
);
662 bcache_xfree (objfile
->macro_cache
);
663 bcache_xfree (objfile
->filename_cache
);
664 if (objfile
->demangled_names_hash
)
665 htab_delete (objfile
->demangled_names_hash
);
666 obstack_free (&objfile
->objfile_obstack
, 0);
668 /* Rebuild section map next time we need it. */
669 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
675 do_free_objfile_cleanup (void *obj
)
681 make_cleanup_free_objfile (struct objfile
*obj
)
683 return make_cleanup (do_free_objfile_cleanup
, obj
);
686 /* Free all the object files at once and clean up their users. */
689 free_all_objfiles (void)
691 struct objfile
*objfile
, *temp
;
694 /* Any objfile referencewould become stale. */
695 for (so
= master_so_list (); so
; so
= so
->next
)
696 gdb_assert (so
->objfile
== NULL
);
698 ALL_OBJFILES_SAFE (objfile
, temp
)
700 free_objfile (objfile
);
702 clear_symtab_users ();
705 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
706 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
707 Return non-zero iff any change happened. */
710 objfile_relocate1 (struct objfile
*objfile
,
711 struct section_offsets
*new_offsets
)
713 struct obj_section
*s
;
714 struct section_offsets
*delta
=
715 ((struct section_offsets
*)
716 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
719 int something_changed
= 0;
721 for (i
= 0; i
< objfile
->num_sections
; ++i
)
724 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
725 if (ANOFFSET (delta
, i
) != 0)
726 something_changed
= 1;
728 if (!something_changed
)
731 /* OK, get all the symtabs. */
735 ALL_OBJFILE_SYMTABS (objfile
, s
)
738 struct blockvector
*bv
;
741 /* First the line table. */
745 for (i
= 0; i
< l
->nitems
; ++i
)
746 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
749 /* Don't relocate a shared blockvector more than once. */
753 bv
= BLOCKVECTOR (s
);
754 if (BLOCKVECTOR_MAP (bv
))
755 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
756 ANOFFSET (delta
, s
->block_line_section
));
758 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
762 struct dict_iterator iter
;
764 b
= BLOCKVECTOR_BLOCK (bv
, i
);
765 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
766 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
768 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
770 fixup_symbol_section (sym
, objfile
);
772 /* The RS6000 code from which this was taken skipped
773 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
774 But I'm leaving out that test, on the theory that
775 they can't possibly pass the tests below. */
776 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
777 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
778 && SYMBOL_SECTION (sym
) >= 0)
780 SYMBOL_VALUE_ADDRESS (sym
) +=
781 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
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
)
898 return objfile
->sf
? objfile
->sf
->qf
->has_symbols (objfile
) : 0;
901 /* Return non-zero if OBJFILE has full symbols. */
904 objfile_has_full_symbols (struct objfile
*objfile
)
906 return objfile
->symtabs
!= NULL
;
909 /* Return non-zero if OBJFILE has full or partial symbols, either directly
910 or through a separate debug file. */
913 objfile_has_symbols (struct objfile
*objfile
)
917 for (o
= objfile
; o
; o
= objfile_separate_debug_iterate (objfile
, o
))
918 if (objfile_has_partial_symbols (o
) || objfile_has_full_symbols (o
))
924 /* Many places in gdb want to test just to see if we have any partial
925 symbols available. This function returns zero if none are currently
926 available, nonzero otherwise. */
929 have_partial_symbols (void)
935 if (objfile_has_partial_symbols (ofp
))
941 /* Many places in gdb want to test just to see if we have any full
942 symbols available. This function returns zero if none are currently
943 available, nonzero otherwise. */
946 have_full_symbols (void)
952 if (objfile_has_full_symbols (ofp
))
959 /* This operations deletes all objfile entries that represent solibs that
960 weren't explicitly loaded by the user, via e.g., the add-symbol-file
964 objfile_purge_solibs (void)
966 struct objfile
*objf
;
967 struct objfile
*temp
;
969 ALL_OBJFILES_SAFE (objf
, temp
)
971 /* We assume that the solib package has been purged already, or will
974 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
980 /* Many places in gdb want to test just to see if we have any minimal
981 symbols available. This function returns zero if none are currently
982 available, nonzero otherwise. */
985 have_minimal_symbols (void)
991 if (ofp
->minimal_symbol_count
> 0)
999 /* Qsort comparison function. */
1002 qsort_cmp (const void *a
, const void *b
)
1004 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
1005 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
1006 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1007 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1009 if (sect1_addr
< sect2_addr
)
1011 else if (sect1_addr
> sect2_addr
)
1015 /* Sections are at the same address. This could happen if
1016 A) we have an objfile and a separate debuginfo.
1017 B) we are confused, and have added sections without proper relocation,
1018 or something like that. */
1020 const struct objfile
*const objfile1
= sect1
->objfile
;
1021 const struct objfile
*const objfile2
= sect2
->objfile
;
1023 if (objfile1
->separate_debug_objfile
== objfile2
1024 || objfile2
->separate_debug_objfile
== objfile1
)
1026 /* Case A. The ordering doesn't matter: separate debuginfo files
1027 will be filtered out later. */
1032 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1033 triage. This section could be slow (since we iterate over all
1034 objfiles in each call to qsort_cmp), but this shouldn't happen
1035 very often (GDB is already in a confused state; one hopes this
1036 doesn't happen at all). If you discover that significant time is
1037 spent in the loops below, do 'set complaints 100' and examine the
1038 resulting complaints. */
1040 if (objfile1
== objfile2
)
1042 /* Both sections came from the same objfile. We are really confused.
1043 Sort on sequence order of sections within the objfile. */
1045 const struct obj_section
*osect
;
1047 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
1050 else if (osect
== sect2
)
1053 /* We should have found one of the sections before getting here. */
1058 /* Sort on sequence number of the objfile in the chain. */
1060 const struct objfile
*objfile
;
1062 ALL_OBJFILES (objfile
)
1063 if (objfile
== objfile1
)
1065 else if (objfile
== objfile2
)
1068 /* We should have found one of the objfiles before getting here. */
1078 /* Select "better" obj_section to keep. We prefer the one that came from
1079 the real object, rather than the one from separate debuginfo.
1080 Most of the time the two sections are exactly identical, but with
1081 prelinking the .rel.dyn section in the real object may have different
1084 static struct obj_section
*
1085 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
1087 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
1088 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
1089 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
1090 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
1091 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
1093 if (a
->objfile
->separate_debug_objfile
!= NULL
)
1098 /* Return 1 if SECTION should be inserted into the section map.
1099 We want to insert only non-overlay and non-TLS section. */
1102 insert_section_p (const struct bfd
*abfd
,
1103 const struct bfd_section
*section
)
1105 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
1107 if (lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
1108 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
1109 /* This is an overlay section. IN_MEMORY check is needed to avoid
1110 discarding sections from the "system supplied DSO" (aka vdso)
1111 on some Linux systems (e.g. Fedora 11). */
1113 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
1114 /* This is a TLS section. */
1120 /* Filter out overlapping sections where one section came from the real
1121 objfile, and the other from a separate debuginfo file.
1122 Return the size of table after redundant sections have been eliminated. */
1125 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1129 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1131 struct obj_section
*const sect1
= map
[i
];
1132 struct obj_section
*const sect2
= map
[i
+ 1];
1133 const struct objfile
*const objfile1
= sect1
->objfile
;
1134 const struct objfile
*const objfile2
= sect2
->objfile
;
1135 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1136 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1138 if (sect1_addr
== sect2_addr
1139 && (objfile1
->separate_debug_objfile
== objfile2
1140 || objfile2
->separate_debug_objfile
== objfile1
))
1142 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1151 gdb_assert (i
== map_size
- 1);
1155 /* The map should not have shrunk to less than half the original size. */
1156 gdb_assert (map_size
/ 2 <= j
);
1161 /* Filter out overlapping sections, issuing a warning if any are found.
1162 Overlapping sections could really be overlay sections which we didn't
1163 classify as such in insert_section_p, or we could be dealing with a
1167 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1171 for (i
= 0, j
= 0; i
< map_size
- 1; )
1176 for (k
= i
+ 1; k
< map_size
; k
++)
1178 struct obj_section
*const sect1
= map
[i
];
1179 struct obj_section
*const sect2
= map
[k
];
1180 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1181 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1182 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1184 gdb_assert (sect1_addr
<= sect2_addr
);
1186 if (sect1_endaddr
<= sect2_addr
)
1190 /* We have an overlap. Report it. */
1192 struct objfile
*const objf1
= sect1
->objfile
;
1193 struct objfile
*const objf2
= sect2
->objfile
;
1195 const struct bfd
*const abfd1
= objf1
->obfd
;
1196 const struct bfd
*const abfd2
= objf2
->obfd
;
1198 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1199 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1201 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1203 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1205 complaint (&symfile_complaints
,
1206 _("unexpected overlap between:\n"
1207 " (A) section `%s' from `%s' [%s, %s)\n"
1208 " (B) section `%s' from `%s' [%s, %s).\n"
1209 "Will ignore section B"),
1210 bfd_section_name (abfd1
, bfds1
), objf1
->name
,
1211 paddress (gdbarch
, sect1_addr
),
1212 paddress (gdbarch
, sect1_endaddr
),
1213 bfd_section_name (abfd2
, bfds2
), objf2
->name
,
1214 paddress (gdbarch
, sect2_addr
),
1215 paddress (gdbarch
, sect2_endaddr
));
1223 gdb_assert (i
== map_size
- 1);
1231 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1232 TLS, overlay and overlapping sections. */
1235 update_section_map (struct program_space
*pspace
,
1236 struct obj_section
***pmap
, int *pmap_size
)
1238 int alloc_size
, map_size
, i
;
1239 struct obj_section
*s
, **map
;
1240 struct objfile
*objfile
;
1242 gdb_assert (get_objfile_pspace_data (pspace
)->objfiles_changed_p
!= 0);
1248 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1249 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1250 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1253 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1254 if (alloc_size
== 0)
1261 map
= xmalloc (alloc_size
* sizeof (*map
));
1264 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1265 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1266 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1269 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1270 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1271 map_size
= filter_overlapping_sections(map
, map_size
);
1273 if (map_size
< alloc_size
)
1274 /* Some sections were eliminated. Trim excess space. */
1275 map
= xrealloc (map
, map_size
* sizeof (*map
));
1277 gdb_assert (alloc_size
== map_size
);
1280 *pmap_size
= map_size
;
1283 /* Bsearch comparison function. */
1286 bsearch_cmp (const void *key
, const void *elt
)
1288 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1289 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1291 if (pc
< obj_section_addr (section
))
1293 if (pc
< obj_section_endaddr (section
))
1298 /* Returns a section whose range includes PC or NULL if none found. */
1300 struct obj_section
*
1301 find_pc_section (CORE_ADDR pc
)
1303 struct objfile_pspace_info
*pspace_info
;
1304 struct obj_section
*s
, **sp
;
1306 /* Check for mapped overlay section first. */
1307 s
= find_pc_mapped_section (pc
);
1311 pspace_info
= get_objfile_pspace_data (current_program_space
);
1312 if (pspace_info
->objfiles_changed_p
!= 0)
1314 update_section_map (current_program_space
,
1315 &pspace_info
->sections
,
1316 &pspace_info
->num_sections
);
1318 /* Don't need updates to section map until objfiles are added,
1319 removed or relocated. */
1320 pspace_info
->objfiles_changed_p
= 0;
1323 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1324 bsearch be non-NULL. */
1325 if (pspace_info
->sections
== NULL
)
1327 gdb_assert (pspace_info
->num_sections
== 0);
1331 sp
= (struct obj_section
**) bsearch (&pc
,
1332 pspace_info
->sections
,
1333 pspace_info
->num_sections
,
1334 sizeof (*pspace_info
->sections
),
1342 /* In SVR4, we recognize a trampoline by it's section name.
1343 That is, if the pc is in a section named ".plt" then we are in
1347 in_plt_section (CORE_ADDR pc
, char *name
)
1349 struct obj_section
*s
;
1352 s
= find_pc_section (pc
);
1355 && s
->the_bfd_section
->name
!= NULL
1356 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
1361 /* Keep a registry of per-objfile data-pointers required by other GDB
1367 void (*save
) (struct objfile
*, void *);
1368 void (*free
) (struct objfile
*, void *);
1371 struct objfile_data_registration
1373 struct objfile_data
*data
;
1374 struct objfile_data_registration
*next
;
1377 struct objfile_data_registry
1379 struct objfile_data_registration
*registrations
;
1380 unsigned num_registrations
;
1383 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
1385 const struct objfile_data
*
1386 register_objfile_data_with_cleanup (void (*save
) (struct objfile
*, void *),
1387 void (*free
) (struct objfile
*, void *))
1389 struct objfile_data_registration
**curr
;
1391 /* Append new registration. */
1392 for (curr
= &objfile_data_registry
.registrations
;
1393 *curr
!= NULL
; curr
= &(*curr
)->next
);
1395 *curr
= XMALLOC (struct objfile_data_registration
);
1396 (*curr
)->next
= NULL
;
1397 (*curr
)->data
= XMALLOC (struct objfile_data
);
1398 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
1399 (*curr
)->data
->save
= save
;
1400 (*curr
)->data
->free
= free
;
1402 return (*curr
)->data
;
1405 const struct objfile_data
*
1406 register_objfile_data (void)
1408 return register_objfile_data_with_cleanup (NULL
, NULL
);
1412 objfile_alloc_data (struct objfile
*objfile
)
1414 gdb_assert (objfile
->data
== NULL
);
1415 objfile
->num_data
= objfile_data_registry
.num_registrations
;
1416 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
1420 objfile_free_data (struct objfile
*objfile
)
1422 gdb_assert (objfile
->data
!= NULL
);
1423 clear_objfile_data (objfile
);
1424 xfree (objfile
->data
);
1425 objfile
->data
= NULL
;
1429 clear_objfile_data (struct objfile
*objfile
)
1431 struct objfile_data_registration
*registration
;
1434 gdb_assert (objfile
->data
!= NULL
);
1436 /* Process all the save handlers. */
1438 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1439 i
< objfile
->num_data
;
1440 registration
= registration
->next
, i
++)
1441 if (objfile
->data
[i
] != NULL
&& registration
->data
->save
!= NULL
)
1442 registration
->data
->save (objfile
, objfile
->data
[i
]);
1444 /* Now process all the free handlers. */
1446 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1447 i
< objfile
->num_data
;
1448 registration
= registration
->next
, i
++)
1449 if (objfile
->data
[i
] != NULL
&& registration
->data
->free
!= NULL
)
1450 registration
->data
->free (objfile
, objfile
->data
[i
]);
1452 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
1456 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
1459 gdb_assert (data
->index
< objfile
->num_data
);
1460 objfile
->data
[data
->index
] = value
;
1464 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
1466 gdb_assert (data
->index
< objfile
->num_data
);
1467 return objfile
->data
[data
->index
];
1470 /* Set objfiles_changed_p so section map will be rebuilt next time it
1471 is used. Called by reread_symbols. */
1474 objfiles_changed (void)
1476 /* Rebuild section map next time we need it. */
1477 get_objfile_pspace_data (current_program_space
)->objfiles_changed_p
= 1;
1480 /* Close ABFD, and warn if that fails. */
1483 gdb_bfd_close_or_warn (struct bfd
*abfd
)
1486 char *name
= bfd_get_filename (abfd
);
1488 ret
= bfd_close (abfd
);
1491 warning (_("cannot close \"%s\": %s"),
1492 name
, bfd_errmsg (bfd_get_error ()));
1497 /* Add reference to ABFD. Returns ABFD. */
1499 gdb_bfd_ref (struct bfd
*abfd
)
1506 p_refcount
= bfd_usrdata (abfd
);
1508 if (p_refcount
!= NULL
)
1514 p_refcount
= xmalloc (sizeof (*p_refcount
));
1516 bfd_usrdata (abfd
) = p_refcount
;
1521 /* Unreference and possibly close ABFD. */
1523 gdb_bfd_unref (struct bfd
*abfd
)
1531 p_refcount
= bfd_usrdata (abfd
);
1533 /* Valid range for p_refcount: a pointer to int counter, which has a
1534 value of 1 (single owner) or 2 (shared). */
1535 gdb_assert (*p_refcount
== 1 || *p_refcount
== 2);
1538 if (*p_refcount
> 0)
1542 bfd_usrdata (abfd
) = NULL
; /* Paranoia. */
1544 name
= bfd_get_filename (abfd
);
1545 gdb_bfd_close_or_warn (abfd
);
1549 /* Provide a prototype to silence -Wmissing-prototypes. */
1550 extern initialize_file_ftype _initialize_objfiles
;
1553 _initialize_objfiles (void)
1555 objfiles_pspace_data
1556 = register_program_space_data_with_cleanup (objfiles_pspace_data_cleanup
);