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
*) xmalloc (sizeof (struct objfile
));
200 memset (objfile
, 0, sizeof (struct objfile
));
201 objfile
->psymbol_cache
= bcache_xmalloc ();
202 objfile
->macro_cache
= bcache_xmalloc ();
203 /* We could use obstack_specify_allocation here instead, but
204 gdb_obstack.h specifies the alloc/dealloc functions. */
205 obstack_init (&objfile
->objfile_obstack
);
206 terminate_minimal_symbol_table (objfile
);
208 objfile_alloc_data (objfile
);
210 /* Update the per-objfile information that comes from the bfd, ensuring
211 that any data that is reference is saved in the per-objfile data
214 objfile
->obfd
= gdb_bfd_ref (abfd
);
215 if (objfile
->name
!= NULL
)
217 xfree (objfile
->name
);
221 /* Look up the gdbarch associated with the BFD. */
222 objfile
->gdbarch
= gdbarch_from_bfd (abfd
);
224 objfile
->name
= xstrdup (bfd_get_filename (abfd
));
225 objfile
->mtime
= bfd_get_mtime (abfd
);
227 /* Build section table. */
229 if (build_objfile_section_table (objfile
))
231 error (_("Can't find the file sections in `%s': %s"),
232 objfile
->name
, bfd_errmsg (bfd_get_error ()));
237 objfile
->name
= xstrdup ("<<anonymous objfile>>");
240 objfile
->pspace
= current_program_space
;
242 /* Initialize the section indexes for this objfile, so that we can
243 later detect if they are used w/o being properly assigned to. */
245 objfile
->sect_index_text
= -1;
246 objfile
->sect_index_data
= -1;
247 objfile
->sect_index_bss
= -1;
248 objfile
->sect_index_rodata
= -1;
250 /* We don't yet have a C++-specific namespace symtab. */
252 objfile
->cp_namespace_symtab
= NULL
;
254 /* Add this file onto the tail of the linked list of other such files. */
256 objfile
->next
= NULL
;
257 if (object_files
== NULL
)
258 object_files
= objfile
;
261 struct objfile
*last_one
;
263 for (last_one
= object_files
;
265 last_one
= last_one
->next
);
266 last_one
->next
= objfile
;
269 /* Save passed in flag bits. */
270 objfile
->flags
|= flags
;
272 /* Rebuild section map next time we need it. */
273 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
278 /* Retrieve the gdbarch associated with OBJFILE. */
280 get_objfile_arch (struct objfile
*objfile
)
282 return objfile
->gdbarch
;
285 /* Initialize entry point information for this objfile. */
288 init_entry_point_info (struct objfile
*objfile
)
290 /* Save startup file's range of PC addresses to help blockframe.c
291 decide where the bottom of the stack is. */
293 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
295 /* Executable file -- record its entry point so we'll recognize
296 the startup file because it contains the entry point. */
297 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
299 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
300 && bfd_get_start_address (objfile
->obfd
) != 0)
301 /* Some shared libraries may have entry points set and be
302 runnable. There's no clear way to indicate this, so just check
303 for values other than zero. */
304 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
307 /* Examination of non-executable.o files. Short-circuit this stuff. */
308 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
312 /* Get current entry point address. */
315 entry_point_address (void)
317 struct gdbarch
*gdbarch
;
318 CORE_ADDR entry_point
;
320 if (symfile_objfile
== NULL
)
323 gdbarch
= get_objfile_arch (symfile_objfile
);
325 entry_point
= symfile_objfile
->ei
.entry_point
;
327 /* Make certain that the address points at real code, and not a
328 function descriptor. */
329 entry_point
= gdbarch_convert_from_func_ptr_addr (gdbarch
, entry_point
,
332 /* Remove any ISA markers, so that this matches entries in the
334 entry_point
= gdbarch_addr_bits_remove (gdbarch
, entry_point
);
339 /* Create the terminating entry of OBJFILE's minimal symbol table.
340 If OBJFILE->msymbols is zero, allocate a single entry from
341 OBJFILE->objfile_obstack; otherwise, just initialize
342 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
344 terminate_minimal_symbol_table (struct objfile
*objfile
)
346 if (! objfile
->msymbols
)
347 objfile
->msymbols
= ((struct minimal_symbol
*)
348 obstack_alloc (&objfile
->objfile_obstack
,
349 sizeof (objfile
->msymbols
[0])));
352 struct minimal_symbol
*m
353 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
355 memset (m
, 0, sizeof (*m
));
356 /* Don't rely on these enumeration values being 0's. */
357 MSYMBOL_TYPE (m
) = mst_unknown
;
358 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
363 /* Put one object file before a specified on in the global list.
364 This can be used to make sure an object file is destroyed before
365 another when using ALL_OBJFILES_SAFE to free all objfiles. */
367 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
369 struct objfile
**objp
;
371 unlink_objfile (objfile
);
373 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
375 if (*objp
== before_this
)
377 objfile
->next
= *objp
;
383 internal_error (__FILE__
, __LINE__
,
384 _("put_objfile_before: before objfile not in list"));
387 /* Put OBJFILE at the front of the list. */
390 objfile_to_front (struct objfile
*objfile
)
392 struct objfile
**objp
;
393 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
395 if (*objp
== objfile
)
397 /* Unhook it from where it is. */
398 *objp
= objfile
->next
;
399 /* Put it in the front. */
400 objfile
->next
= object_files
;
401 object_files
= objfile
;
407 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
410 It is not a bug, or error, to call this function if OBJFILE is not known
411 to be in the current list. This is done in the case of mapped objfiles,
412 for example, just to ensure that the mapped objfile doesn't appear twice
413 in the list. Since the list is threaded, linking in a mapped objfile
414 twice would create a circular list.
416 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
417 unlinking it, just to ensure that we have completely severed any linkages
418 between the OBJFILE and the list. */
421 unlink_objfile (struct objfile
*objfile
)
423 struct objfile
**objpp
;
425 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
427 if (*objpp
== objfile
)
429 *objpp
= (*objpp
)->next
;
430 objfile
->next
= NULL
;
435 internal_error (__FILE__
, __LINE__
,
436 _("unlink_objfile: objfile already unlinked"));
440 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
441 that as much as possible is allocated on the objfile_obstack
442 so that the memory can be efficiently freed.
444 Things which we do NOT free because they are not in malloc'd memory
445 or not in memory specific to the objfile include:
449 FIXME: If the objfile is using reusable symbol information (via mmalloc),
450 then we need to take into account the fact that more than one process
451 may be using the symbol information at the same time (when mmalloc is
452 extended to support cooperative locking). When more than one process
453 is using the mapped symbol info, we need to be more careful about when
454 we free objects in the reusable area. */
457 free_objfile (struct objfile
*objfile
)
459 if (objfile
->separate_debug_objfile
)
461 free_objfile (objfile
->separate_debug_objfile
);
464 if (objfile
->separate_debug_objfile_backlink
)
466 /* We freed the separate debug file, make sure the base objfile
467 doesn't reference it. */
468 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
471 /* Remove any references to this objfile in the global value
473 preserve_values (objfile
);
475 /* First do any symbol file specific actions required when we are
476 finished with a particular symbol file. Note that if the objfile
477 is using reusable symbol information (via mmalloc) then each of
478 these routines is responsible for doing the correct thing, either
479 freeing things which are valid only during this particular gdb
480 execution, or leaving them to be reused during the next one. */
482 if (objfile
->sf
!= NULL
)
484 (*objfile
->sf
->sym_finish
) (objfile
);
487 /* Discard any data modules have associated with the objfile. */
488 objfile_free_data (objfile
);
490 gdb_bfd_unref (objfile
->obfd
);
492 /* Remove it from the chain of all objfiles. */
494 unlink_objfile (objfile
);
496 if (objfile
== symfile_objfile
)
497 symfile_objfile
= NULL
;
499 if (objfile
== rt_common_objfile
)
500 rt_common_objfile
= NULL
;
502 /* Before the symbol table code was redone to make it easier to
503 selectively load and remove information particular to a specific
504 linkage unit, gdb used to do these things whenever the monolithic
505 symbol table was blown away. How much still needs to be done
506 is unknown, but we play it safe for now and keep each action until
507 it is shown to be no longer needed. */
509 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
510 for example), so we need to call this here. */
511 clear_pc_function_cache ();
513 /* Clear globals which might have pointed into a removed objfile.
514 FIXME: It's not clear which of these are supposed to persist
515 between expressions and which ought to be reset each time. */
516 expression_context_block
= NULL
;
517 innermost_block
= NULL
;
519 /* Check to see if the current_source_symtab belongs to this objfile,
520 and if so, call clear_current_source_symtab_and_line. */
523 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
526 ALL_OBJFILE_SYMTABS (objfile
, s
)
528 if (s
== cursal
.symtab
)
529 clear_current_source_symtab_and_line ();
533 /* The last thing we do is free the objfile struct itself. */
535 if (objfile
->name
!= NULL
)
537 xfree (objfile
->name
);
539 if (objfile
->global_psymbols
.list
)
540 xfree (objfile
->global_psymbols
.list
);
541 if (objfile
->static_psymbols
.list
)
542 xfree (objfile
->static_psymbols
.list
);
543 /* Free the obstacks for non-reusable objfiles */
544 bcache_xfree (objfile
->psymbol_cache
);
545 bcache_xfree (objfile
->macro_cache
);
546 if (objfile
->demangled_names_hash
)
547 htab_delete (objfile
->demangled_names_hash
);
548 obstack_free (&objfile
->objfile_obstack
, 0);
550 /* Rebuild section map next time we need it. */
551 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
557 do_free_objfile_cleanup (void *obj
)
563 make_cleanup_free_objfile (struct objfile
*obj
)
565 return make_cleanup (do_free_objfile_cleanup
, obj
);
568 /* Free all the object files at once and clean up their users. */
571 free_all_objfiles (void)
573 struct objfile
*objfile
, *temp
;
575 ALL_OBJFILES_SAFE (objfile
, temp
)
577 free_objfile (objfile
);
579 clear_symtab_users ();
582 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
583 entries in new_offsets. */
585 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
587 struct obj_section
*s
;
588 struct section_offsets
*delta
=
589 ((struct section_offsets
*)
590 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
594 int something_changed
= 0;
595 for (i
= 0; i
< objfile
->num_sections
; ++i
)
598 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
599 if (ANOFFSET (delta
, i
) != 0)
600 something_changed
= 1;
602 if (!something_changed
)
606 /* OK, get all the symtabs. */
610 ALL_OBJFILE_SYMTABS (objfile
, s
)
613 struct blockvector
*bv
;
616 /* First the line table. */
620 for (i
= 0; i
< l
->nitems
; ++i
)
621 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
624 /* Don't relocate a shared blockvector more than once. */
628 bv
= BLOCKVECTOR (s
);
629 if (BLOCKVECTOR_MAP (bv
))
630 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
631 ANOFFSET (delta
, s
->block_line_section
));
633 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
637 struct dict_iterator iter
;
639 b
= BLOCKVECTOR_BLOCK (bv
, i
);
640 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
641 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
643 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
645 fixup_symbol_section (sym
, objfile
);
647 /* The RS6000 code from which this was taken skipped
648 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
649 But I'm leaving out that test, on the theory that
650 they can't possibly pass the tests below. */
651 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
652 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
653 && SYMBOL_SECTION (sym
) >= 0)
655 SYMBOL_VALUE_ADDRESS (sym
) +=
656 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
664 struct partial_symtab
*p
;
666 ALL_OBJFILE_PSYMTABS (objfile
, p
)
668 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
669 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
674 struct partial_symbol
**psym
;
676 for (psym
= objfile
->global_psymbols
.list
;
677 psym
< objfile
->global_psymbols
.next
;
680 fixup_psymbol_section (*psym
, objfile
);
681 if (SYMBOL_SECTION (*psym
) >= 0)
682 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
683 SYMBOL_SECTION (*psym
));
685 for (psym
= objfile
->static_psymbols
.list
;
686 psym
< objfile
->static_psymbols
.next
;
689 fixup_psymbol_section (*psym
, objfile
);
690 if (SYMBOL_SECTION (*psym
) >= 0)
691 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
692 SYMBOL_SECTION (*psym
));
697 struct minimal_symbol
*msym
;
698 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
699 if (SYMBOL_SECTION (msym
) >= 0)
700 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
702 /* Relocating different sections by different amounts may cause the symbols
703 to be out of order. */
704 msymbols_sort (objfile
);
706 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
708 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
709 only as a fallback. */
710 struct obj_section
*s
;
711 s
= find_pc_section (objfile
->ei
.entry_point
);
713 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
715 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
720 for (i
= 0; i
< objfile
->num_sections
; ++i
)
721 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
724 /* Rebuild section map next time we need it. */
725 get_objfile_pspace_data (objfile
->pspace
)->objfiles_changed_p
= 1;
727 /* Update the table in exec_ops, used to read memory. */
728 ALL_OBJFILE_OSECTIONS (objfile
, s
)
730 int idx
= s
->the_bfd_section
->index
;
732 exec_set_section_address (bfd_get_filename (objfile
->obfd
), idx
,
733 obj_section_addr (s
));
736 /* Relocate breakpoints as necessary, after things are relocated. */
737 breakpoint_re_set ();
740 /* Return non-zero if OBJFILE has partial symbols. */
743 objfile_has_partial_symbols (struct objfile
*objfile
)
745 return objfile
->psymtabs
!= NULL
;
748 /* Return non-zero if OBJFILE has full symbols. */
751 objfile_has_full_symbols (struct objfile
*objfile
)
753 return objfile
->symtabs
!= NULL
;
756 /* Return non-zero if OBJFILE has full or partial symbols, either directly
757 or throught its separate debug file. */
760 objfile_has_symbols (struct objfile
*objfile
)
762 struct objfile
*separate_objfile
;
764 if (objfile_has_partial_symbols (objfile
)
765 || objfile_has_full_symbols (objfile
))
768 separate_objfile
= objfile
->separate_debug_objfile
;
769 if (separate_objfile
== NULL
)
772 if (objfile_has_partial_symbols (separate_objfile
)
773 || objfile_has_full_symbols (separate_objfile
))
780 /* Many places in gdb want to test just to see if we have any partial
781 symbols available. This function returns zero if none are currently
782 available, nonzero otherwise. */
785 have_partial_symbols (void)
791 if (objfile_has_partial_symbols (ofp
))
797 /* Many places in gdb want to test just to see if we have any full
798 symbols available. This function returns zero if none are currently
799 available, nonzero otherwise. */
802 have_full_symbols (void)
808 if (objfile_has_full_symbols (ofp
))
815 /* This operations deletes all objfile entries that represent solibs that
816 weren't explicitly loaded by the user, via e.g., the add-symbol-file
820 objfile_purge_solibs (void)
822 struct objfile
*objf
;
823 struct objfile
*temp
;
825 ALL_OBJFILES_SAFE (objf
, temp
)
827 /* We assume that the solib package has been purged already, or will
830 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
836 /* Many places in gdb want to test just to see if we have any minimal
837 symbols available. This function returns zero if none are currently
838 available, nonzero otherwise. */
841 have_minimal_symbols (void)
847 if (ofp
->minimal_symbol_count
> 0)
855 /* Qsort comparison function. */
858 qsort_cmp (const void *a
, const void *b
)
860 const struct obj_section
*sect1
= *(const struct obj_section
**) a
;
861 const struct obj_section
*sect2
= *(const struct obj_section
**) b
;
862 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
863 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
865 if (sect1_addr
< sect2_addr
)
867 else if (sect1_addr
> sect2_addr
)
871 /* Sections are at the same address. This could happen if
872 A) we have an objfile and a separate debuginfo.
873 B) we are confused, and have added sections without proper relocation,
874 or something like that. */
876 const struct objfile
*const objfile1
= sect1
->objfile
;
877 const struct objfile
*const objfile2
= sect2
->objfile
;
879 if (objfile1
->separate_debug_objfile
== objfile2
880 || objfile2
->separate_debug_objfile
== objfile1
)
882 /* Case A. The ordering doesn't matter: separate debuginfo files
883 will be filtered out later. */
888 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
889 triage. This section could be slow (since we iterate over all
890 objfiles in each call to qsort_cmp), but this shouldn't happen
891 very often (GDB is already in a confused state; one hopes this
892 doesn't happen at all). If you discover that significant time is
893 spent in the loops below, do 'set complaints 100' and examine the
894 resulting complaints. */
896 if (objfile1
== objfile2
)
898 /* Both sections came from the same objfile. We are really confused.
899 Sort on sequence order of sections within the objfile. */
901 const struct obj_section
*osect
;
903 ALL_OBJFILE_OSECTIONS (objfile1
, osect
)
906 else if (osect
== sect2
)
909 /* We should have found one of the sections before getting here. */
914 /* Sort on sequence number of the objfile in the chain. */
916 const struct objfile
*objfile
;
918 ALL_OBJFILES (objfile
)
919 if (objfile
== objfile1
)
921 else if (objfile
== objfile2
)
924 /* We should have found one of the objfiles before getting here. */
935 /* Select "better" obj_section to keep. We prefer the one that came from
936 the real object, rather than the one from separate debuginfo.
937 Most of the time the two sections are exactly identical, but with
938 prelinking the .rel.dyn section in the real object may have different
941 static struct obj_section
*
942 preferred_obj_section (struct obj_section
*a
, struct obj_section
*b
)
944 gdb_assert (obj_section_addr (a
) == obj_section_addr (b
));
945 gdb_assert ((a
->objfile
->separate_debug_objfile
== b
->objfile
)
946 || (b
->objfile
->separate_debug_objfile
== a
->objfile
));
947 gdb_assert ((a
->objfile
->separate_debug_objfile_backlink
== b
->objfile
)
948 || (b
->objfile
->separate_debug_objfile_backlink
== a
->objfile
));
950 if (a
->objfile
->separate_debug_objfile
!= NULL
)
955 /* Return 1 if SECTION should be inserted into the section map.
956 We want to insert only non-overlay and non-TLS section. */
959 insert_section_p (const struct bfd
*abfd
,
960 const struct bfd_section
*section
)
962 const bfd_vma lma
= bfd_section_lma (abfd
, section
);
964 if (lma
!= 0 && lma
!= bfd_section_vma (abfd
, section
)
965 && (bfd_get_file_flags (abfd
) & BFD_IN_MEMORY
) == 0)
966 /* This is an overlay section. IN_MEMORY check is needed to avoid
967 discarding sections from the "system supplied DSO" (aka vdso)
968 on some Linux systems (e.g. Fedora 11). */
970 if ((bfd_get_section_flags (abfd
, section
) & SEC_THREAD_LOCAL
) != 0)
971 /* This is a TLS section. */
977 /* Filter out overlapping sections where one section came from the real
978 objfile, and the other from a separate debuginfo file.
979 Return the size of table after redundant sections have been eliminated. */
982 filter_debuginfo_sections (struct obj_section
**map
, int map_size
)
986 for (i
= 0, j
= 0; i
< map_size
- 1; i
++)
988 struct obj_section
*const sect1
= map
[i
];
989 struct obj_section
*const sect2
= map
[i
+ 1];
990 const struct objfile
*const objfile1
= sect1
->objfile
;
991 const struct objfile
*const objfile2
= sect2
->objfile
;
992 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
993 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
995 if (sect1_addr
== sect2_addr
996 && (objfile1
->separate_debug_objfile
== objfile2
997 || objfile2
->separate_debug_objfile
== objfile1
))
999 map
[j
++] = preferred_obj_section (sect1
, sect2
);
1008 gdb_assert (i
== map_size
- 1);
1012 /* The map should not have shrunk to less than half the original size. */
1013 gdb_assert (map_size
/ 2 <= j
);
1018 /* Filter out overlapping sections, issuing a warning if any are found.
1019 Overlapping sections could really be overlay sections which we didn't
1020 classify as such in insert_section_p, or we could be dealing with a
1024 filter_overlapping_sections (struct obj_section
**map
, int map_size
)
1028 for (i
= 0, j
= 0; i
< map_size
- 1; )
1033 for (k
= i
+ 1; k
< map_size
; k
++)
1035 struct obj_section
*const sect1
= map
[i
];
1036 struct obj_section
*const sect2
= map
[k
];
1037 const CORE_ADDR sect1_addr
= obj_section_addr (sect1
);
1038 const CORE_ADDR sect2_addr
= obj_section_addr (sect2
);
1039 const CORE_ADDR sect1_endaddr
= obj_section_endaddr (sect1
);
1041 gdb_assert (sect1_addr
<= sect2_addr
);
1043 if (sect1_endaddr
<= sect2_addr
)
1047 /* We have an overlap. Report it. */
1049 struct objfile
*const objf1
= sect1
->objfile
;
1050 struct objfile
*const objf2
= sect2
->objfile
;
1052 const struct bfd
*const abfd1
= objf1
->obfd
;
1053 const struct bfd
*const abfd2
= objf2
->obfd
;
1055 const struct bfd_section
*const bfds1
= sect1
->the_bfd_section
;
1056 const struct bfd_section
*const bfds2
= sect2
->the_bfd_section
;
1058 const CORE_ADDR sect2_endaddr
= obj_section_endaddr (sect2
);
1060 struct gdbarch
*const gdbarch
= get_objfile_arch (objf1
);
1062 complaint (&symfile_complaints
,
1063 _("unexpected overlap between:\n"
1064 " (A) section `%s' from `%s' [%s, %s)\n"
1065 " (B) section `%s' from `%s' [%s, %s).\n"
1066 "Will ignore section B"),
1067 bfd_section_name (abfd1
, bfds1
), objf1
->name
,
1068 paddress (gdbarch
, sect1_addr
),
1069 paddress (gdbarch
, sect1_endaddr
),
1070 bfd_section_name (abfd2
, bfds2
), objf2
->name
,
1071 paddress (gdbarch
, sect2_addr
),
1072 paddress (gdbarch
, sect2_endaddr
));
1080 gdb_assert (i
== map_size
- 1);
1088 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1089 TLS, overlay and overlapping sections. */
1092 update_section_map (struct program_space
*pspace
,
1093 struct obj_section
***pmap
, int *pmap_size
)
1095 int alloc_size
, map_size
, i
;
1096 struct obj_section
*s
, **map
;
1097 struct objfile
*objfile
;
1099 gdb_assert (get_objfile_pspace_data (pspace
)->objfiles_changed_p
!= 0);
1105 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1106 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1107 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1110 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1111 if (alloc_size
== 0)
1118 map
= xmalloc (alloc_size
* sizeof (*map
));
1121 ALL_PSPACE_OBJFILES (pspace
, objfile
)
1122 ALL_OBJFILE_OSECTIONS (objfile
, s
)
1123 if (insert_section_p (objfile
->obfd
, s
->the_bfd_section
))
1126 qsort (map
, alloc_size
, sizeof (*map
), qsort_cmp
);
1127 map_size
= filter_debuginfo_sections(map
, alloc_size
);
1128 map_size
= filter_overlapping_sections(map
, map_size
);
1130 if (map_size
< alloc_size
)
1131 /* Some sections were eliminated. Trim excess space. */
1132 map
= xrealloc (map
, map_size
* sizeof (*map
));
1134 gdb_assert (alloc_size
== map_size
);
1137 *pmap_size
= map_size
;
1140 /* Bsearch comparison function. */
1143 bsearch_cmp (const void *key
, const void *elt
)
1145 const CORE_ADDR pc
= *(CORE_ADDR
*) key
;
1146 const struct obj_section
*section
= *(const struct obj_section
**) elt
;
1148 if (pc
< obj_section_addr (section
))
1150 if (pc
< obj_section_endaddr (section
))
1155 /* Returns a section whose range includes PC or NULL if none found. */
1157 struct obj_section
*
1158 find_pc_section (CORE_ADDR pc
)
1160 struct objfile_pspace_info
*pspace_info
;
1161 struct obj_section
*s
, **sp
;
1163 /* Check for mapped overlay section first. */
1164 s
= find_pc_mapped_section (pc
);
1168 pspace_info
= get_objfile_pspace_data (current_program_space
);
1169 if (pspace_info
->objfiles_changed_p
!= 0)
1171 update_section_map (current_program_space
,
1172 &pspace_info
->sections
,
1173 &pspace_info
->num_sections
);
1175 /* Don't need updates to section map until objfiles are added,
1176 removed or relocated. */
1177 pspace_info
->objfiles_changed_p
= 0;
1180 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1181 bsearch be non-NULL. */
1182 if (pspace_info
->sections
== NULL
)
1184 gdb_assert (pspace_info
->num_sections
== 0);
1188 sp
= (struct obj_section
**) bsearch (&pc
,
1189 pspace_info
->sections
,
1190 pspace_info
->num_sections
,
1191 sizeof (*pspace_info
->sections
),
1199 /* In SVR4, we recognize a trampoline by it's section name.
1200 That is, if the pc is in a section named ".plt" then we are in
1204 in_plt_section (CORE_ADDR pc
, char *name
)
1206 struct obj_section
*s
;
1209 s
= find_pc_section (pc
);
1212 && s
->the_bfd_section
->name
!= NULL
1213 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
1218 /* Keep a registry of per-objfile data-pointers required by other GDB
1224 void (*save
) (struct objfile
*, void *);
1225 void (*free
) (struct objfile
*, void *);
1228 struct objfile_data_registration
1230 struct objfile_data
*data
;
1231 struct objfile_data_registration
*next
;
1234 struct objfile_data_registry
1236 struct objfile_data_registration
*registrations
;
1237 unsigned num_registrations
;
1240 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
1242 const struct objfile_data
*
1243 register_objfile_data_with_cleanup (void (*save
) (struct objfile
*, void *),
1244 void (*free
) (struct objfile
*, void *))
1246 struct objfile_data_registration
**curr
;
1248 /* Append new registration. */
1249 for (curr
= &objfile_data_registry
.registrations
;
1250 *curr
!= NULL
; curr
= &(*curr
)->next
);
1252 *curr
= XMALLOC (struct objfile_data_registration
);
1253 (*curr
)->next
= NULL
;
1254 (*curr
)->data
= XMALLOC (struct objfile_data
);
1255 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
1256 (*curr
)->data
->save
= save
;
1257 (*curr
)->data
->free
= free
;
1259 return (*curr
)->data
;
1262 const struct objfile_data
*
1263 register_objfile_data (void)
1265 return register_objfile_data_with_cleanup (NULL
, NULL
);
1269 objfile_alloc_data (struct objfile
*objfile
)
1271 gdb_assert (objfile
->data
== NULL
);
1272 objfile
->num_data
= objfile_data_registry
.num_registrations
;
1273 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
1277 objfile_free_data (struct objfile
*objfile
)
1279 gdb_assert (objfile
->data
!= NULL
);
1280 clear_objfile_data (objfile
);
1281 xfree (objfile
->data
);
1282 objfile
->data
= NULL
;
1286 clear_objfile_data (struct objfile
*objfile
)
1288 struct objfile_data_registration
*registration
;
1291 gdb_assert (objfile
->data
!= NULL
);
1293 /* Process all the save handlers. */
1295 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1296 i
< objfile
->num_data
;
1297 registration
= registration
->next
, i
++)
1298 if (objfile
->data
[i
] != NULL
&& registration
->data
->save
!= NULL
)
1299 registration
->data
->save (objfile
, objfile
->data
[i
]);
1301 /* Now process all the free handlers. */
1303 for (registration
= objfile_data_registry
.registrations
, i
= 0;
1304 i
< objfile
->num_data
;
1305 registration
= registration
->next
, i
++)
1306 if (objfile
->data
[i
] != NULL
&& registration
->data
->free
!= NULL
)
1307 registration
->data
->free (objfile
, objfile
->data
[i
]);
1309 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
1313 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
1316 gdb_assert (data
->index
< objfile
->num_data
);
1317 objfile
->data
[data
->index
] = value
;
1321 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
1323 gdb_assert (data
->index
< objfile
->num_data
);
1324 return objfile
->data
[data
->index
];
1327 /* Set objfiles_changed_p so section map will be rebuilt next time it
1328 is used. Called by reread_symbols. */
1331 objfiles_changed (void)
1333 /* Rebuild section map next time we need it. */
1334 get_objfile_pspace_data (current_program_space
)->objfiles_changed_p
= 1;
1337 /* Add reference to ABFD. Returns ABFD. */
1339 gdb_bfd_ref (struct bfd
*abfd
)
1341 int *p_refcount
= bfd_usrdata (abfd
);
1343 if (p_refcount
!= NULL
)
1349 p_refcount
= xmalloc (sizeof (*p_refcount
));
1351 bfd_usrdata (abfd
) = p_refcount
;
1356 /* Unreference and possibly close ABFD. */
1358 gdb_bfd_unref (struct bfd
*abfd
)
1366 p_refcount
= bfd_usrdata (abfd
);
1368 /* Valid range for p_refcount: a pointer to int counter, which has a
1369 value of 1 (single owner) or 2 (shared). */
1370 gdb_assert (*p_refcount
== 1 || *p_refcount
== 2);
1373 if (*p_refcount
> 0)
1377 bfd_usrdata (abfd
) = NULL
; /* Paranoia. */
1379 name
= bfd_get_filename (abfd
);
1380 if (!bfd_close (abfd
))
1381 warning (_("cannot close \"%s\": %s"),
1382 name
, bfd_errmsg (bfd_get_error ()));
1386 /* Provide a prototype to silence -Wmissing-prototypes. */
1387 extern initialize_file_ftype _initialize_objfiles
;
1390 _initialize_objfiles (void)
1392 objfiles_pspace_data
1393 = register_program_space_data_with_cleanup (objfiles_pspace_data_cleanup
);