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 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"
56 /* Prototypes for local functions */
58 static void objfile_alloc_data (struct objfile
*objfile
);
59 static void objfile_free_data (struct objfile
*objfile
);
61 /* Externally visible variables that are owned by this module.
62 See declarations in objfile.h for more info. */
64 struct objfile
*current_objfile
; /* For symbol file being read in */
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
, (char *) §ion
, sizeof (section
));
139 objfile
->sections_end
140 = (struct obj_section
*) (((size_t) objfile
->sections_end
) + 1);
143 /* Builds a section table for OBJFILE.
144 Returns 0 if OK, 1 on error (in which case bfd_error contains the
147 Note that while we are building the table, which goes into the
148 psymbol obstack, we hijack the sections_end pointer to instead hold
149 a count of the number of sections. When bfd_map_over_sections
150 returns, this count is used to compute the pointer to the end of
151 the sections table, which then overwrites the count.
153 Also note that the OFFSET and OVLY_MAPPED in each table entry
154 are initialized to zero.
156 Also note that if anything else writes to the psymbol obstack while
157 we are building the table, we're pretty much hosed. */
160 build_objfile_section_table (struct objfile
*objfile
)
162 /* objfile->sections can be already set when reading a mapped symbol
163 file. I believe that we do need to rebuild the section table in
164 this case (we rebuild other things derived from the bfd), but we
165 can't free the old one (it's in the objfile_obstack). So we just
166 waste some memory. */
168 objfile
->sections_end
= 0;
169 bfd_map_over_sections (objfile
->obfd
,
170 add_to_objfile_sections
, (void *) objfile
);
171 objfile
->sections
= obstack_finish (&objfile
->objfile_obstack
);
172 objfile
->sections_end
= objfile
->sections
+ (size_t) objfile
->sections_end
;
176 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
177 allocate a new objfile struct, fill it in as best we can, link it
178 into the list of all known objfiles, and return a pointer to the
181 The FLAGS word contains various bits (OBJF_*) that can be taken as
182 requests for specific operations. Other bits like OBJF_SHARED are
183 simply copied through to the new objfile flags member. */
185 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
186 by jv-lang.c, to create an artificial objfile used to hold
187 information about dynamically-loaded Java classes. Unfortunately,
188 that branch of this function doesn't get tested very frequently, so
189 it's prone to breakage. (E.g. at one time the name was set to NULL
190 in that situation, which broke a loop over all names in the dynamic
191 library loader.) If you change this function, please try to leave
192 things in a consistent state even if abfd is NULL. */
195 allocate_objfile (bfd
*abfd
, int flags
)
197 struct objfile
*objfile
;
199 objfile
= (struct objfile
*) xzalloc (sizeof (struct objfile
));
200 objfile
->psymbol_cache
= bcache_xmalloc ();
201 objfile
->macro_cache
= bcache_xmalloc ();
202 /* We could use obstack_specify_allocation here instead, but
203 gdb_obstack.h specifies the alloc/dealloc functions. */
204 obstack_init (&objfile
->objfile_obstack
);
205 terminate_minimal_symbol_table (objfile
);
207 objfile_alloc_data (objfile
);
209 /* Update the per-objfile information that comes from the bfd, ensuring
210 that any data that is reference is saved in the per-objfile data
213 objfile
->obfd
= gdb_bfd_ref (abfd
);
214 if (objfile
->name
!= NULL
)
216 xfree (objfile
->name
);
220 /* Look up the gdbarch associated with the BFD. */
221 objfile
->gdbarch
= gdbarch_from_bfd (abfd
);
223 objfile
->name
= xstrdup (bfd_get_filename (abfd
));
224 objfile
->mtime
= bfd_get_mtime (abfd
);
226 /* Build section table. */
228 if (build_objfile_section_table (objfile
))
230 error (_("Can't find the file sections in `%s': %s"),
231 objfile
->name
, bfd_errmsg (bfd_get_error ()));
236 objfile
->name
= xstrdup ("<<anonymous objfile>>");
239 objfile
->pspace
= current_program_space
;
241 /* Initialize the section indexes for this objfile, so that we can
242 later detect if they are used w/o being properly assigned to. */
244 objfile
->sect_index_text
= -1;
245 objfile
->sect_index_data
= -1;
246 objfile
->sect_index_bss
= -1;
247 objfile
->sect_index_rodata
= -1;
249 /* We don't yet have a C++-specific namespace symtab. */
251 objfile
->cp_namespace_symtab
= NULL
;
253 /* Add this file onto the tail of the linked list of other such files. */
255 objfile
->next
= NULL
;
256 if (object_files
== NULL
)
257 object_files
= objfile
;
260 struct objfile
*last_one
;
262 for (last_one
= object_files
;
264 last_one
= last_one
->next
);
265 last_one
->next
= objfile
;
268 /* Save passed in flag bits. */
269 objfile
->flags
|= flags
;
271 /* Rebuild section map next time we need it. */
272 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
277 /* Retrieve the gdbarch associated with OBJFILE. */
279 get_objfile_arch (struct objfile
*objfile
)
281 return objfile
->gdbarch
;
284 /* Initialize entry point information for this objfile. */
287 init_entry_point_info (struct objfile
*objfile
)
289 /* Save startup file's range of PC addresses to help blockframe.c
290 decide where the bottom of the stack is. */
292 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
294 /* Executable file -- record its entry point so we'll recognize
295 the startup file because it contains the entry point. */
296 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
297 objfile
->ei
.entry_point_p
= 1;
299 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
300 && bfd_get_start_address (objfile
->obfd
) != 0)
302 /* Some shared libraries may have entry points set and be
303 runnable. There's no clear way to indicate this, so just check
304 for values other than zero. */
305 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
306 objfile
->ei
.entry_point_p
= 1;
310 /* Examination of non-executable.o files. Short-circuit this stuff. */
311 objfile
->ei
.entry_point_p
= 0;
315 /* If there is a valid and known entry point, function fills *ENTRY_P with it
316 and returns non-zero; otherwise it returns zero. */
319 entry_point_address_query (CORE_ADDR
*entry_p
)
321 struct gdbarch
*gdbarch
;
322 CORE_ADDR entry_point
;
324 if (symfile_objfile
== NULL
|| !symfile_objfile
->ei
.entry_point_p
)
327 gdbarch
= get_objfile_arch (symfile_objfile
);
329 entry_point
= symfile_objfile
->ei
.entry_point
;
331 /* Make certain that the address points at real code, and not a
332 function descriptor. */
333 entry_point
= gdbarch_convert_from_func_ptr_addr (gdbarch
, entry_point
,
336 /* Remove any ISA markers, so that this matches entries in the
338 entry_point
= gdbarch_addr_bits_remove (gdbarch
, entry_point
);
340 *entry_p
= entry_point
;
344 /* Get current entry point address. Call error if it is not known. */
347 entry_point_address (void)
351 if (!entry_point_address_query (&retval
))
352 error (_("Entry point address is not known."));
357 /* Create the terminating entry of OBJFILE's minimal symbol table.
358 If OBJFILE->msymbols is zero, allocate a single entry from
359 OBJFILE->objfile_obstack; otherwise, just initialize
360 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
362 terminate_minimal_symbol_table (struct objfile
*objfile
)
364 if (! objfile
->msymbols
)
365 objfile
->msymbols
= ((struct minimal_symbol
*)
366 obstack_alloc (&objfile
->objfile_obstack
,
367 sizeof (objfile
->msymbols
[0])));
370 struct minimal_symbol
*m
371 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
373 memset (m
, 0, sizeof (*m
));
374 /* Don't rely on these enumeration values being 0's. */
375 MSYMBOL_TYPE (m
) = mst_unknown
;
376 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
381 /* Put one object file before a specified on in the global list.
382 This can be used to make sure an object file is destroyed before
383 another when using ALL_OBJFILES_SAFE to free all objfiles. */
385 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
387 struct objfile
**objp
;
389 unlink_objfile (objfile
);
391 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
393 if (*objp
== before_this
)
395 objfile
->next
= *objp
;
401 internal_error (__FILE__
, __LINE__
,
402 _("put_objfile_before: before objfile not in list"));
405 /* Put OBJFILE at the front of the list. */
408 objfile_to_front (struct objfile
*objfile
)
410 struct objfile
**objp
;
411 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
413 if (*objp
== objfile
)
415 /* Unhook it from where it is. */
416 *objp
= objfile
->next
;
417 /* Put it in the front. */
418 objfile
->next
= object_files
;
419 object_files
= objfile
;
425 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
428 It is not a bug, or error, to call this function if OBJFILE is not known
429 to be in the current list. This is done in the case of mapped objfiles,
430 for example, just to ensure that the mapped objfile doesn't appear twice
431 in the list. Since the list is threaded, linking in a mapped objfile
432 twice would create a circular list.
434 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
435 unlinking it, just to ensure that we have completely severed any linkages
436 between the OBJFILE and the list. */
439 unlink_objfile (struct objfile
*objfile
)
441 struct objfile
**objpp
;
443 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
445 if (*objpp
== objfile
)
447 *objpp
= (*objpp
)->next
;
448 objfile
->next
= NULL
;
453 internal_error (__FILE__
, __LINE__
,
454 _("unlink_objfile: objfile already unlinked"));
458 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
459 that as much as possible is allocated on the objfile_obstack
460 so that the memory can be efficiently freed.
462 Things which we do NOT free because they are not in malloc'd memory
463 or not in memory specific to the objfile include:
467 FIXME: If the objfile is using reusable symbol information (via mmalloc),
468 then we need to take into account the fact that more than one process
469 may be using the symbol information at the same time (when mmalloc is
470 extended to support cooperative locking). When more than one process
471 is using the mapped symbol info, we need to be more careful about when
472 we free objects in the reusable area. */
475 free_objfile (struct objfile
*objfile
)
477 if (objfile
->separate_debug_objfile
)
479 free_objfile (objfile
->separate_debug_objfile
);
482 if (objfile
->separate_debug_objfile_backlink
)
484 /* We freed the separate debug file, make sure the base objfile
485 doesn't reference it. */
486 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
489 /* Remove any references to this objfile in the global value
491 preserve_values (objfile
);
493 /* First do any symbol file specific actions required when we are
494 finished with a particular symbol file. Note that if the objfile
495 is using reusable symbol information (via mmalloc) then each of
496 these routines is responsible for doing the correct thing, either
497 freeing things which are valid only during this particular gdb
498 execution, or leaving them to be reused during the next one. */
500 if (objfile
->sf
!= NULL
)
502 (*objfile
->sf
->sym_finish
) (objfile
);
505 /* Discard any data modules have associated with the objfile. */
506 objfile_free_data (objfile
);
508 gdb_bfd_unref (objfile
->obfd
);
510 /* Remove it from the chain of all objfiles. */
512 unlink_objfile (objfile
);
514 if (objfile
== symfile_objfile
)
515 symfile_objfile
= NULL
;
517 if (objfile
== rt_common_objfile
)
518 rt_common_objfile
= NULL
;
520 /* Before the symbol table code was redone to make it easier to
521 selectively load and remove information particular to a specific
522 linkage unit, gdb used to do these things whenever the monolithic
523 symbol table was blown away. How much still needs to be done
524 is unknown, but we play it safe for now and keep each action until
525 it is shown to be no longer needed. */
527 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
528 for example), so we need to call this here. */
529 clear_pc_function_cache ();
531 /* Clear globals which might have pointed into a removed objfile.
532 FIXME: It's not clear which of these are supposed to persist
533 between expressions and which ought to be reset each time. */
534 expression_context_block
= NULL
;
535 innermost_block
= NULL
;
537 /* Check to see if the current_source_symtab belongs to this objfile,
538 and if so, call clear_current_source_symtab_and_line. */
541 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
544 ALL_OBJFILE_SYMTABS (objfile
, s
)
546 if (s
== cursal
.symtab
)
547 clear_current_source_symtab_and_line ();
551 /* The last thing we do is free the objfile struct itself. */
553 if (objfile
->name
!= NULL
)
555 xfree (objfile
->name
);
557 if (objfile
->global_psymbols
.list
)
558 xfree (objfile
->global_psymbols
.list
);
559 if (objfile
->static_psymbols
.list
)
560 xfree (objfile
->static_psymbols
.list
);
561 /* Free the obstacks for non-reusable objfiles */
562 bcache_xfree (objfile
->psymbol_cache
);
563 bcache_xfree (objfile
->macro_cache
);
564 if (objfile
->demangled_names_hash
)
565 htab_delete (objfile
->demangled_names_hash
);
566 obstack_free (&objfile
->objfile_obstack
, 0);
568 /* Rebuild section map next time we need it. */
569 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
575 do_free_objfile_cleanup (void *obj
)
581 make_cleanup_free_objfile (struct objfile
*obj
)
583 return make_cleanup (do_free_objfile_cleanup
, obj
);
586 /* Free all the object files at once and clean up their users. */
589 free_all_objfiles (void)
591 struct objfile
*objfile
, *temp
;
593 ALL_OBJFILES_SAFE (objfile
, temp
)
595 free_objfile (objfile
);
597 clear_symtab_users ();
600 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
601 entries in new_offsets. */
603 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
605 struct obj_section
*s
;
606 struct section_offsets
*delta
=
607 ((struct section_offsets
*)
608 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
612 int something_changed
= 0;
613 for (i
= 0; i
< objfile
->num_sections
; ++i
)
616 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
617 if (ANOFFSET (delta
, i
) != 0)
618 something_changed
= 1;
620 if (!something_changed
)
624 /* OK, get all the symtabs. */
628 ALL_OBJFILE_SYMTABS (objfile
, s
)
631 struct blockvector
*bv
;
634 /* First the line table. */
638 for (i
= 0; i
< l
->nitems
; ++i
)
639 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
642 /* Don't relocate a shared blockvector more than once. */
646 bv
= BLOCKVECTOR (s
);
647 if (BLOCKVECTOR_MAP (bv
))
648 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
649 ANOFFSET (delta
, s
->block_line_section
));
651 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
655 struct dict_iterator iter
;
657 b
= BLOCKVECTOR_BLOCK (bv
, i
);
658 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
659 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
661 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
663 fixup_symbol_section (sym
, objfile
);
665 /* The RS6000 code from which this was taken skipped
666 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
667 But I'm leaving out that test, on the theory that
668 they can't possibly pass the tests below. */
669 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
670 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
671 && SYMBOL_SECTION (sym
) >= 0)
673 SYMBOL_VALUE_ADDRESS (sym
) +=
674 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
682 struct partial_symtab
*p
;
684 ALL_OBJFILE_PSYMTABS (objfile
, p
)
686 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
687 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
692 struct partial_symbol
**psym
;
694 for (psym
= objfile
->global_psymbols
.list
;
695 psym
< objfile
->global_psymbols
.next
;
698 fixup_psymbol_section (*psym
, objfile
);
699 if (SYMBOL_SECTION (*psym
) >= 0)
700 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
701 SYMBOL_SECTION (*psym
));
703 for (psym
= objfile
->static_psymbols
.list
;
704 psym
< objfile
->static_psymbols
.next
;
707 fixup_psymbol_section (*psym
, objfile
);
708 if (SYMBOL_SECTION (*psym
) >= 0)
709 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
710 SYMBOL_SECTION (*psym
));
715 struct minimal_symbol
*msym
;
716 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
717 if (SYMBOL_SECTION (msym
) >= 0)
718 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
720 /* Relocating different sections by different amounts may cause the symbols
721 to be out of order. */
722 msymbols_sort (objfile
);
724 if (objfile
->ei
.entry_point_p
)
726 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
727 only as a fallback. */
728 struct obj_section
*s
;
729 s
= find_pc_section (objfile
->ei
.entry_point
);
731 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
733 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
738 for (i
= 0; i
< objfile
->num_sections
; ++i
)
739 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
742 /* Rebuild section map next time we need it. */
743 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
745 /* Update the table in exec_ops, used to read memory. */
746 ALL_OBJFILE_OSECTIONS (objfile
, s
)
748 int idx
= s
->the_bfd_section
->index
;
750 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
751 obj_section_addr (s
));
754 /* Relocate breakpoints as necessary, after things are relocated. */
755 breakpoint_re_set ();
758 /* Return non-zero if OBJFILE has partial symbols. */
761 objfile_has_partial_symbols (struct objfile
*objfile
)
763 return objfile
->psymtabs
!= NULL
;
766 /* Return non-zero if OBJFILE has full symbols. */
769 objfile_has_full_symbols (struct objfile
*objfile
)
771 return objfile
->symtabs
!= NULL
;
774 /* Return non-zero if OBJFILE has full or partial symbols, either directly
775 or throught its separate debug file. */
778 objfile_has_symbols (struct objfile
*objfile
)
780 struct objfile
*separate_objfile
;
782 if (objfile_has_partial_symbols (objfile
)
783 || objfile_has_full_symbols (objfile
))
786 separate_objfile
= objfile
->separate_debug_objfile
;
787 if (separate_objfile
== NULL
)
790 if (objfile_has_partial_symbols (separate_objfile
)
791 || objfile_has_full_symbols (separate_objfile
))
798 /* Many places in gdb want to test just to see if we have any partial
799 symbols available. This function returns zero if none are currently
800 available, nonzero otherwise. */
803 have_partial_symbols (void)
809 if (objfile_has_partial_symbols (ofp
))
815 /* Many places in gdb want to test just to see if we have any full
816 symbols available. This function returns zero if none are currently
817 available, nonzero otherwise. */
820 have_full_symbols (void)
826 if (objfile_has_full_symbols (ofp
))
833 /* This operations deletes all objfile entries that represent solibs that
834 weren't explicitly loaded by the user, via e.g., the add-symbol-file
838 objfile_purge_solibs (void)
840 struct objfile
*objf
;
841 struct objfile
*temp
;
843 ALL_OBJFILES_SAFE (objf
, temp
)
845 /* We assume that the solib package has been purged already, or will
848 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
854 /* Many places in gdb want to test just to see if we have any minimal
855 symbols available. This function returns zero if none are currently
856 available, nonzero otherwise. */
859 have_minimal_symbols (void)
865 if (ofp
->minimal_symbol_count
> 0)
873 /* Qsort comparison function. */
876 qsort_cmp (const void *a
, const void *b
)
878 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
879 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
880 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
881 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
883 if (sect1_addr
< sect2_addr
)
885 else if (sect1_addr
> sect2_addr
)
889 /* Sections are at the same address. This could happen if
890 A) we have an objfile and a separate debuginfo.
891 B) we are confused, and have added sections without proper relocation,
892 or something like that. */
894 const struct objfile
*const objfile1
= sect1
->objfile
;
895 const struct objfile
*const objfile2
= sect2
->objfile
;
897 if (objfile1
->separate_debug_objfile
== objfile2
898 || objfile2
->separate_debug_objfile
== objfile1
)
900 /* Case A. The ordering doesn't matter: separate debuginfo files
901 will be filtered out later. */
906 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
907 triage. This section could be slow (since we iterate over all
908 objfiles in each call to qsort_cmp), but this shouldn't happen
909 very often (GDB is already in a confused state; one hopes this
910 doesn't happen at all). If you discover that significant time is
911 spent in the loops below, do 'set complaints 100' and examine the
912 resulting complaints. */
914 if (objfile1
== objfile2
)
916 /* Both sections came from the same objfile. We are really confused.
917 Sort on sequence order of sections within the objfile. */
919 const struct obj_section
*osect
;
921 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
924 else if (osect
== sect2
)
927 /* We should have found one of the sections before getting here. */
932 /* Sort on sequence number of the objfile in the chain. */
934 const struct objfile
*objfile
;
936 ALL_OBJFILES (objfile
)
937 if (objfile
== objfile1
)
939 else if (objfile
== objfile2
)
942 /* We should have found one of the objfiles before getting here. */
953 /* Select "better" obj_section to keep. We prefer the one that came from
954 the real object, rather than the one from separate debuginfo.
955 Most of the time the two sections are exactly identical, but with
956 prelinking the .rel.dyn section in the real object may have different
959 static struct obj_section
*
960 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
962 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
963 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
964 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
965 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
966 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
968 if (a
->objfile
->separate_debug_objfile
!= NULL
)
973 /* Return 1 if SECTION should be inserted into the section map.
974 We want to insert only non-overlay and non-TLS section. */
977 insert_section_p (const struct bfd
*abfd
,
978 const struct bfd_section
*section
)
980 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
982 if (lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
983 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
984 /* This is an overlay section. IN_MEMORY check is needed to avoid
985 discarding sections from the "system supplied DSO" (aka vdso)
986 on some Linux systems (e.g. Fedora 11). */
988 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
989 /* This is a TLS section. */
995 /* Filter out overlapping sections where one section came from the real
996 objfile, and the other from a separate debuginfo file.
997 Return the size of table after redundant sections have been eliminated. */
1000 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
1004 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
1006 struct obj_section
*const sect1
= map
[i
];
1007 struct obj_section
*const sect2
= map
[i
+ 1];
1008 const struct objfile
*const objfile1
= sect1
->objfile
;
1009 const struct objfile
*const objfile2
= sect2
->objfile
;
1010 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1011 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1013 if (sect1_addr
== sect2_addr
1014 && (objfile1
->separate_debug_objfile
== objfile2
1015 || objfile2
->separate_debug_objfile
== objfile1
))
1017 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1026 gdb_assert (i
== map_size
- 1);
1030 /* The map should not have shrunk to less than half the original size. */
1031 gdb_assert (map_size
/ 2 <= j
);
1036 /* Filter out overlapping sections, issuing a warning if any are found.
1037 Overlapping sections could really be overlay sections which we didn't
1038 classify as such in insert_section_p, or we could be dealing with a
1042 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1046 for (i
= 0, j
= 0; i
< map_size
- 1; )
1051 for (k
= i
+ 1; k
< map_size
; k
++)
1053 struct obj_section
*const sect1
= map
[i
];
1054 struct obj_section
*const sect2
= map
[k
];
1055 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1056 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1057 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1059 gdb_assert (sect1_addr
<= sect2_addr
);
1061 if (sect1_endaddr
<= sect2_addr
)
1065 /* We have an overlap. Report it. */
1067 struct objfile
*const objf1
= sect1
->objfile
;
1068 struct objfile
*const objf2
= sect2
->objfile
;
1070 const struct bfd
*const abfd1
= objf1
->obfd
;
1071 const struct bfd
*const abfd2
= objf2
->obfd
;
1073 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1074 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1076 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1078 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1080 complaint (&symfile_complaints
,
1081 _("unexpected overlap between:\n"
1082 " (A) section `%s' from `%s' [%s, %s)\n"
1083 " (B) section `%s' from `%s' [%s, %s).\n"
1084 "Will ignore section B"),
1085 bfd_section_name (abfd1
, bfds1
), objf1
->name
,
1086 paddress (gdbarch
, sect1_addr
),
1087 paddress (gdbarch
, sect1_endaddr
),
1088 bfd_section_name (abfd2
, bfds2
), objf2
->name
,
1089 paddress (gdbarch
, sect2_addr
),
1090 paddress (gdbarch
, sect2_endaddr
));
1098 gdb_assert (i
== map_size
- 1);
1106 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1107 TLS, overlay and overlapping sections. */
1110 update_section_map (struct program_space
*pspace
,
1111 struct obj_section
***pmap
, int *pmap_size
)
1113 int alloc_size
, map_size
, i
;
1114 struct obj_section
*s
, **map
;
1115 struct objfile
*objfile
;
1117 gdb_assert (get_objfile_pspace_data (pspace
)->objfiles_changed_p
!= 0);
1123 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1124 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1125 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1128 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1129 if (alloc_size
== 0)
1136 map
= xmalloc (alloc_size
* sizeof (*map
));
1139 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1140 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1141 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1144 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1145 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1146 map_size
= filter_overlapping_sections(map
, map_size
);
1148 if (map_size
< alloc_size
)
1149 /* Some sections were eliminated. Trim excess space. */
1150 map
= xrealloc (map
, map_size
* sizeof (*map
));
1152 gdb_assert (alloc_size
== map_size
);
1155 *pmap_size
= map_size
;
1158 /* Bsearch comparison function. */
1161 bsearch_cmp (const void *key
, const void *elt
)
1163 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1164 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1166 if (pc
< obj_section_addr (section
))
1168 if (pc
< obj_section_endaddr (section
))
1173 /* Returns a section whose range includes PC or NULL if none found. */
1175 struct obj_section
*
1176 find_pc_section (CORE_ADDR pc
)
1178 struct objfile_pspace_info
*pspace_info
;
1179 struct obj_section
*s
, **sp
;
1181 /* Check for mapped overlay section first. */
1182 s
= find_pc_mapped_section (pc
);
1186 pspace_info
= get_objfile_pspace_data (current_program_space
);
1187 if (pspace_info
->objfiles_changed_p
!= 0)
1189 update_section_map (current_program_space
,
1190 &pspace_info
->sections
,
1191 &pspace_info
->num_sections
);
1193 /* Don't need updates to section map until objfiles are added,
1194 removed or relocated. */
1195 pspace_info
->objfiles_changed_p
= 0;
1198 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1199 bsearch be non-NULL. */
1200 if (pspace_info
->sections
== NULL
)
1202 gdb_assert (pspace_info
->num_sections
== 0);
1206 sp
= (struct obj_section
**) bsearch (&pc
,
1207 pspace_info
->sections
,
1208 pspace_info
->num_sections
,
1209 sizeof (*pspace_info
->sections
),
1217 /* In SVR4, we recognize a trampoline by it's section name.
1218 That is, if the pc is in a section named ".plt" then we are in
1222 in_plt_section (CORE_ADDR pc
, char *name
)
1224 struct obj_section
*s
;
1227 s
= find_pc_section (pc
);
1230 && s
->the_bfd_section
->name
!= NULL
1231 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
1236 /* Keep a registry of per-objfile data-pointers required by other GDB
1242 void (*save
) (struct objfile
*, void *);
1243 void (*free
) (struct objfile
*, void *);
1246 struct objfile_data_registration
1248 struct objfile_data
*data
;
1249 struct objfile_data_registration
*next
;
1252 struct objfile_data_registry
1254 struct objfile_data_registration
*registrations
;
1255 unsigned num_registrations
;
1258 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
1260 const struct objfile_data
*
1261 register_objfile_data_with_cleanup (void (*save
) (struct objfile
*, void *),
1262 void (*free
) (struct objfile
*, void *))
1264 struct objfile_data_registration
**curr
;
1266 /* Append new registration. */
1267 for (curr
= &objfile_data_registry
.registrations
;
1268 *curr
!= NULL
; curr
= &(*curr
)->next
);
1270 *curr
= XMALLOC (struct objfile_data_registration
);
1271 (*curr
)->next
= NULL
;
1272 (*curr
)->data
= XMALLOC (struct objfile_data
);
1273 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
1274 (*curr
)->data
->save
= save
;
1275 (*curr
)->data
->free
= free
;
1277 return (*curr
)->data
;
1280 const struct objfile_data
*
1281 register_objfile_data (void)
1283 return register_objfile_data_with_cleanup (NULL
, NULL
);
1287 objfile_alloc_data (struct objfile
*objfile
)
1289 gdb_assert (objfile
->data
== NULL
);
1290 objfile
->num_data
= objfile_data_registry
.num_registrations
;
1291 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
1295 objfile_free_data (struct objfile
*objfile
)
1297 gdb_assert (objfile
->data
!= NULL
);
1298 clear_objfile_data (objfile
);
1299 xfree (objfile
->data
);
1300 objfile
->data
= NULL
;
1304 clear_objfile_data (struct objfile
*objfile
)
1306 struct objfile_data_registration
*registration
;
1309 gdb_assert (objfile
->data
!= NULL
);
1311 /* Process all the save handlers. */
1313 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1314 i
< objfile
->num_data
;
1315 registration
= registration
->next
, i
++)
1316 if (objfile
->data
[i
] != NULL
&& registration
->data
->save
!= NULL
)
1317 registration
->data
->save (objfile
, objfile
->data
[i
]);
1319 /* Now process all the free handlers. */
1321 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1322 i
< objfile
->num_data
;
1323 registration
= registration
->next
, i
++)
1324 if (objfile
->data
[i
] != NULL
&& registration
->data
->free
!= NULL
)
1325 registration
->data
->free (objfile
, objfile
->data
[i
]);
1327 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
1331 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
1334 gdb_assert (data
->index
< objfile
->num_data
);
1335 objfile
->data
[data
->index
] = value
;
1339 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
1341 gdb_assert (data
->index
< objfile
->num_data
);
1342 return objfile
->data
[data
->index
];
1345 /* Set objfiles_changed_p so section map will be rebuilt next time it
1346 is used. Called by reread_symbols. */
1349 objfiles_changed (void)
1351 /* Rebuild section map next time we need it. */
1352 get_objfile_pspace_data (current_program_space
)->objfiles_changed_p
= 1;
1355 /* Add reference to ABFD. Returns ABFD. */
1357 gdb_bfd_ref (struct bfd
*abfd
)
1359 int *p_refcount
= bfd_usrdata (abfd
);
1361 if (p_refcount
!= NULL
)
1367 p_refcount
= xmalloc (sizeof (*p_refcount
));
1369 bfd_usrdata (abfd
) = p_refcount
;
1374 /* Unreference and possibly close ABFD. */
1376 gdb_bfd_unref (struct bfd
*abfd
)
1384 p_refcount
= bfd_usrdata (abfd
);
1386 /* Valid range for p_refcount: a pointer to int counter, which has a
1387 value of 1 (single owner) or 2 (shared). */
1388 gdb_assert (*p_refcount
== 1 || *p_refcount
== 2);
1391 if (*p_refcount
> 0)
1395 bfd_usrdata (abfd
) = NULL
; /* Paranoia. */
1397 name
= bfd_get_filename (abfd
);
1398 if (!bfd_close (abfd
))
1399 warning (_("cannot close \"%s\": %s"),
1400 name
, bfd_errmsg (bfd_get_error ()));
1404 /* Provide a prototype to silence -Wmissing-prototypes. */
1405 extern initialize_file_ftype _initialize_objfiles
;
1408 _initialize_objfiles (void)
1410 objfiles_pspace_data
1411 = register_program_space_data_with_cleanup (objfiles_pspace_data_cleanup
);