1 /* GDB routines for manipulating objfiles.
3 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 2001, 2002, 2003 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 2 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, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* This file contains support routines for creating, manipulating, and
26 destroying objfile structures. */
29 #include "bfd.h" /* Binary File Description */
33 #include "gdb-stabs.h"
37 #include <sys/types.h>
40 #include "gdb_obstack.h"
41 #include "gdb_string.h"
44 #include "breakpoint.h"
46 #include "dictionary.h"
48 /* Prototypes for local functions */
50 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
54 static int open_existing_mapped_file (char *, long, int);
56 static int open_mapped_file (char *filename
, long mtime
, int flags
);
58 static void *map_to_file (int);
60 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
62 static void add_to_objfile_sections (bfd
*, sec_ptr
, void *);
64 /* Externally visible variables that are owned by this module.
65 See declarations in objfile.h for more info. */
67 struct objfile
*object_files
; /* Linked list of all objfiles */
68 struct objfile
*current_objfile
; /* For symbol file being read in */
69 struct objfile
*symfile_objfile
; /* Main symbol table loaded from */
70 struct objfile
*rt_common_objfile
; /* For runtime common symbols */
72 int mapped_symbol_files
; /* Try to use mapped symbol files */
74 /* Locate all mappable sections of a BFD file.
75 objfile_p_char is a char * to get it through
76 bfd_map_over_sections; we cast it back to its proper type. */
78 #ifndef TARGET_KEEP_SECTION
79 #define TARGET_KEEP_SECTION(ASECT) 0
82 /* Called via bfd_map_over_sections to build up the section table that
83 the objfile references. The objfile contains pointers to the start
84 of the table (objfile->sections) and to the first location after
85 the end of the table (objfile->sections_end). */
88 add_to_objfile_sections (bfd
*abfd
, sec_ptr asect
, void *objfile_p_char
)
90 struct objfile
*objfile
= (struct objfile
*) objfile_p_char
;
91 struct obj_section section
;
94 aflag
= bfd_get_section_flags (abfd
, asect
);
96 if (!(aflag
& SEC_ALLOC
) && !(TARGET_KEEP_SECTION (asect
)))
99 if (0 == bfd_section_size (abfd
, asect
))
102 section
.objfile
= objfile
;
103 section
.the_bfd_section
= asect
;
104 section
.ovly_mapped
= 0;
105 section
.addr
= bfd_section_vma (abfd
, asect
);
106 section
.endaddr
= section
.addr
+ bfd_section_size (abfd
, asect
);
107 obstack_grow (&objfile
->psymbol_obstack
, (char *) §ion
, sizeof (section
));
108 objfile
->sections_end
= (struct obj_section
*) (((unsigned long) objfile
->sections_end
) + 1);
111 /* Builds a section table for OBJFILE.
112 Returns 0 if OK, 1 on error (in which case bfd_error contains the
115 Note that while we are building the table, which goes into the
116 psymbol obstack, we hijack the sections_end pointer to instead hold
117 a count of the number of sections. When bfd_map_over_sections
118 returns, this count is used to compute the pointer to the end of
119 the sections table, which then overwrites the count.
121 Also note that the OFFSET and OVLY_MAPPED in each table entry
122 are initialized to zero.
124 Also note that if anything else writes to the psymbol obstack while
125 we are building the table, we're pretty much hosed. */
128 build_objfile_section_table (struct objfile
*objfile
)
130 /* objfile->sections can be already set when reading a mapped symbol
131 file. I believe that we do need to rebuild the section table in
132 this case (we rebuild other things derived from the bfd), but we
133 can't free the old one (it's in the psymbol_obstack). So we just
134 waste some memory. */
136 objfile
->sections_end
= 0;
137 bfd_map_over_sections (objfile
->obfd
, add_to_objfile_sections
, (char *) objfile
);
138 objfile
->sections
= (struct obj_section
*)
139 obstack_finish (&objfile
->psymbol_obstack
);
140 objfile
->sections_end
= objfile
->sections
+ (unsigned long) objfile
->sections_end
;
144 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
145 allocate a new objfile struct, fill it in as best we can, link it
146 into the list of all known objfiles, and return a pointer to the
149 The FLAGS word contains various bits (OBJF_*) that can be taken as
150 requests for specific operations, like trying to open a mapped
151 version of the objfile (OBJF_MAPPED). Other bits like
152 OBJF_SHARED are simply copied through to the new objfile flags
155 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
156 by jv-lang.c, to create an artificial objfile used to hold
157 information about dynamically-loaded Java classes. Unfortunately,
158 that branch of this function doesn't get tested very frequently, so
159 it's prone to breakage. (E.g. at one time the name was set to NULL
160 in that situation, which broke a loop over all names in the dynamic
161 library loader.) If you change this function, please try to leave
162 things in a consistent state even if abfd is NULL. */
165 allocate_objfile (bfd
*abfd
, int flags
)
167 struct objfile
*objfile
= NULL
;
168 struct objfile
*last_one
= NULL
;
170 if (mapped_symbol_files
)
171 flags
|= OBJF_MAPPED
;
173 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
177 /* If we can support mapped symbol files, try to open/reopen the
178 mapped file that corresponds to the file from which we wish to
179 read symbols. If the objfile is to be mapped, we must malloc
180 the structure itself using the mmap version, and arrange that
181 all memory allocation for the objfile uses the mmap routines.
182 If we are reusing an existing mapped file, from which we get
183 our objfile pointer, we have to make sure that we update the
184 pointers to the alloc/free functions in the obstack, in case
185 these functions have moved within the current gdb. */
189 fd
= open_mapped_file (bfd_get_filename (abfd
), bfd_get_mtime (abfd
),
195 if ((md
= map_to_file (fd
)) == NULL
)
199 else if ((objfile
= (struct objfile
*) mmalloc_getkey (md
, 0)) != NULL
)
201 /* Update memory corruption handler function addresses. */
205 /* Update pointers to functions to *our* copies */
206 if (objfile
->demangled_names_hash
)
207 htab_set_functions_ex
208 (objfile
->demangled_names_hash
, htab_hash_string
,
209 (int (*) (const void *, const void *)) streq
, NULL
,
210 objfile
->md
, xmcalloc
, xmfree
);
211 obstack_chunkfun (&objfile
->psymbol_cache
.cache
, xmmalloc
);
212 obstack_freefun (&objfile
->psymbol_cache
.cache
, xmfree
);
213 obstack_chunkfun (&objfile
->macro_cache
.cache
, xmmalloc
);
214 obstack_freefun (&objfile
->macro_cache
.cache
, xmfree
);
215 obstack_chunkfun (&objfile
->psymbol_obstack
, xmmalloc
);
216 obstack_freefun (&objfile
->psymbol_obstack
, xmfree
);
217 obstack_chunkfun (&objfile
->symbol_obstack
, xmmalloc
);
218 obstack_freefun (&objfile
->symbol_obstack
, xmfree
);
219 obstack_chunkfun (&objfile
->type_obstack
, xmmalloc
);
220 obstack_freefun (&objfile
->type_obstack
, xmfree
);
221 /* If already in objfile list, unlink it. */
222 unlink_objfile (objfile
);
223 /* Forget things specific to a particular gdb, may have changed. */
229 /* Set up to detect internal memory corruption. MUST be
230 done before the first malloc. See comments in
231 init_malloc() and mmcheck(). */
235 objfile
= (struct objfile
*)
236 xmmalloc (md
, sizeof (struct objfile
));
237 memset (objfile
, 0, sizeof (struct objfile
));
240 objfile
->flags
|= OBJF_MAPPED
;
241 mmalloc_setkey (objfile
->md
, 0, objfile
);
242 obstack_specify_allocation_with_arg (&objfile
->psymbol_cache
.cache
,
243 0, 0, xmmalloc
, xmfree
,
245 obstack_specify_allocation_with_arg (&objfile
->macro_cache
.cache
,
246 0, 0, xmmalloc
, xmfree
,
248 obstack_specify_allocation_with_arg (&objfile
->psymbol_obstack
,
249 0, 0, xmmalloc
, xmfree
,
251 obstack_specify_allocation_with_arg (&objfile
->symbol_obstack
,
252 0, 0, xmmalloc
, xmfree
,
254 obstack_specify_allocation_with_arg (&objfile
->type_obstack
,
255 0, 0, xmmalloc
, xmfree
,
260 if ((flags
& OBJF_MAPPED
) && (objfile
== NULL
))
262 warning ("symbol table for '%s' will not be mapped",
263 bfd_get_filename (abfd
));
264 flags
&= ~OBJF_MAPPED
;
267 #else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
269 if (flags
& OBJF_MAPPED
)
271 warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
273 /* Turn off the global flag so we don't try to do mapped symbol tables
274 any more, which shuts up gdb unless the user specifically gives the
275 "mapped" keyword again. */
277 mapped_symbol_files
= 0;
278 flags
&= ~OBJF_MAPPED
;
281 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
283 /* If we don't support mapped symbol files, didn't ask for the file to be
284 mapped, or failed to open the mapped file for some reason, then revert
285 back to an unmapped objfile. */
289 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
290 memset (objfile
, 0, sizeof (struct objfile
));
292 objfile
->psymbol_cache
= bcache_xmalloc ();
293 objfile
->macro_cache
= bcache_xmalloc ();
294 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0, xmalloc
,
296 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0, xmalloc
,
298 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0, xmalloc
,
300 flags
&= ~OBJF_MAPPED
;
302 terminate_minimal_symbol_table (objfile
);
305 /* Update the per-objfile information that comes from the bfd, ensuring
306 that any data that is reference is saved in the per-objfile data
309 objfile
->obfd
= abfd
;
310 if (objfile
->name
!= NULL
)
312 xmfree (objfile
->md
, objfile
->name
);
316 objfile
->name
= mstrsave (objfile
->md
, bfd_get_filename (abfd
));
317 objfile
->mtime
= bfd_get_mtime (abfd
);
319 /* Build section table. */
321 if (build_objfile_section_table (objfile
))
323 error ("Can't find the file sections in `%s': %s",
324 objfile
->name
, bfd_errmsg (bfd_get_error ()));
329 objfile
->name
= mstrsave (objfile
->md
, "<<anonymous objfile>>");
332 /* Initialize the section indexes for this objfile, so that we can
333 later detect if they are used w/o being properly assigned to. */
335 objfile
->sect_index_text
= -1;
336 objfile
->sect_index_data
= -1;
337 objfile
->sect_index_bss
= -1;
338 objfile
->sect_index_rodata
= -1;
340 /* Add this file onto the tail of the linked list of other such files. */
342 objfile
->next
= NULL
;
343 if (object_files
== NULL
)
344 object_files
= objfile
;
347 for (last_one
= object_files
;
349 last_one
= last_one
->next
);
350 last_one
->next
= objfile
;
353 /* Save passed in flag bits. */
354 objfile
->flags
|= flags
;
360 /* Create the terminating entry of OBJFILE's minimal symbol table.
361 If OBJFILE->msymbols is zero, allocate a single entry from
362 OBJFILE->symbol_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
->symbol_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 DEPRECATED_SYMBOL_NAME (m
) = NULL
;
378 SYMBOL_VALUE_ADDRESS (m
) = 0;
379 MSYMBOL_INFO (m
) = NULL
;
380 MSYMBOL_TYPE (m
) = mst_unknown
;
381 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
386 /* Put one object file before a specified on in the global list.
387 This can be used to make sure an object file is destroyed before
388 another when using ALL_OBJFILES_SAFE to free all objfiles. */
390 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
392 struct objfile
**objp
;
394 unlink_objfile (objfile
);
396 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
398 if (*objp
== before_this
)
400 objfile
->next
= *objp
;
406 internal_error (__FILE__
, __LINE__
,
407 "put_objfile_before: before objfile not in list");
410 /* Put OBJFILE at the front of the list. */
413 objfile_to_front (struct objfile
*objfile
)
415 struct objfile
**objp
;
416 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
418 if (*objp
== objfile
)
420 /* Unhook it from where it is. */
421 *objp
= objfile
->next
;
422 /* Put it in the front. */
423 objfile
->next
= object_files
;
424 object_files
= objfile
;
430 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
433 It is not a bug, or error, to call this function if OBJFILE is not known
434 to be in the current list. This is done in the case of mapped objfiles,
435 for example, just to ensure that the mapped objfile doesn't appear twice
436 in the list. Since the list is threaded, linking in a mapped objfile
437 twice would create a circular list.
439 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
440 unlinking it, just to ensure that we have completely severed any linkages
441 between the OBJFILE and the list. */
444 unlink_objfile (struct objfile
*objfile
)
446 struct objfile
**objpp
;
448 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
450 if (*objpp
== objfile
)
452 *objpp
= (*objpp
)->next
;
453 objfile
->next
= NULL
;
458 internal_error (__FILE__
, __LINE__
,
459 "unlink_objfile: objfile already unlinked");
463 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
464 that as much as possible is allocated on the symbol_obstack and
465 psymbol_obstack, so that the memory can be efficiently freed.
467 Things which we do NOT free because they are not in malloc'd memory
468 or not in memory specific to the objfile include:
472 FIXME: If the objfile is using reusable symbol information (via mmalloc),
473 then we need to take into account the fact that more than one process
474 may be using the symbol information at the same time (when mmalloc is
475 extended to support cooperative locking). When more than one process
476 is using the mapped symbol info, we need to be more careful about when
477 we free objects in the reusable area. */
480 free_objfile (struct objfile
*objfile
)
482 if (objfile
->separate_debug_objfile
)
484 free_objfile (objfile
->separate_debug_objfile
);
487 if (objfile
->separate_debug_objfile_backlink
)
489 /* We freed the separate debug file, make sure the base objfile
490 doesn't reference it. */
491 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
494 /* First do any symbol file specific actions required when we are
495 finished with a particular symbol file. Note that if the objfile
496 is using reusable symbol information (via mmalloc) then each of
497 these routines is responsible for doing the correct thing, either
498 freeing things which are valid only during this particular gdb
499 execution, or leaving them to be reused during the next one. */
501 if (objfile
->sf
!= NULL
)
503 (*objfile
->sf
->sym_finish
) (objfile
);
506 /* We always close the bfd. */
508 if (objfile
->obfd
!= NULL
)
510 char *name
= bfd_get_filename (objfile
->obfd
);
511 if (!bfd_close (objfile
->obfd
))
512 warning ("cannot close \"%s\": %s",
513 name
, bfd_errmsg (bfd_get_error ()));
517 /* Remove it from the chain of all objfiles. */
519 unlink_objfile (objfile
);
521 /* If we are going to free the runtime common objfile, mark it
524 if (objfile
== rt_common_objfile
)
525 rt_common_objfile
= NULL
;
527 /* Before the symbol table code was redone to make it easier to
528 selectively load and remove information particular to a specific
529 linkage unit, gdb used to do these things whenever the monolithic
530 symbol table was blown away. How much still needs to be done
531 is unknown, but we play it safe for now and keep each action until
532 it is shown to be no longer needed. */
534 /* I *think* all our callers call clear_symtab_users. If so, no need
535 to call this here. */
536 clear_pc_function_cache ();
538 /* The last thing we do is free the objfile struct itself for the
539 non-reusable case, or detach from the mapped file for the
540 reusable case. Note that the mmalloc_detach or the xmfree() is
541 the last thing we can do with this objfile. */
543 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
545 if (objfile
->flags
& OBJF_MAPPED
)
547 /* Remember the fd so we can close it. We can't close it before
548 doing the detach, and after the detach the objfile is gone. */
551 mmfd
= objfile
->mmfd
;
552 mmalloc_detach (objfile
->md
);
557 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
559 /* If we still have an objfile, then either we don't support reusable
560 objfiles or this one was not reusable. So free it normally. */
564 if (objfile
->name
!= NULL
)
566 xmfree (objfile
->md
, objfile
->name
);
568 if (objfile
->global_psymbols
.list
)
569 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
570 if (objfile
->static_psymbols
.list
)
571 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
572 /* Free the obstacks for non-reusable objfiles */
573 bcache_xfree (objfile
->psymbol_cache
);
574 bcache_xfree (objfile
->macro_cache
);
575 if (objfile
->demangled_names_hash
)
576 htab_delete (objfile
->demangled_names_hash
);
577 obstack_free (&objfile
->psymbol_obstack
, 0);
578 obstack_free (&objfile
->symbol_obstack
, 0);
579 obstack_free (&objfile
->type_obstack
, 0);
580 xmfree (objfile
->md
, objfile
);
586 do_free_objfile_cleanup (void *obj
)
592 make_cleanup_free_objfile (struct objfile
*obj
)
594 return make_cleanup (do_free_objfile_cleanup
, obj
);
597 /* Free all the object files at once and clean up their users. */
600 free_all_objfiles (void)
602 struct objfile
*objfile
, *temp
;
604 ALL_OBJFILES_SAFE (objfile
, temp
)
606 free_objfile (objfile
);
608 clear_symtab_users ();
611 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
612 entries in new_offsets. */
614 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
616 struct section_offsets
*delta
=
617 ((struct section_offsets
*)
618 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
622 int something_changed
= 0;
623 for (i
= 0; i
< objfile
->num_sections
; ++i
)
626 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
627 if (ANOFFSET (delta
, i
) != 0)
628 something_changed
= 1;
630 if (!something_changed
)
634 /* OK, get all the symtabs. */
638 ALL_OBJFILE_SYMTABS (objfile
, s
)
641 struct blockvector
*bv
;
644 /* First the line table. */
648 for (i
= 0; i
< l
->nitems
; ++i
)
649 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
652 /* Don't relocate a shared blockvector more than once. */
656 bv
= BLOCKVECTOR (s
);
657 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
661 struct dict_iterator iter
;
663 b
= BLOCKVECTOR_BLOCK (bv
, i
);
664 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
665 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
667 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
669 fixup_symbol_section (sym
, objfile
);
671 /* The RS6000 code from which this was taken skipped
672 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
673 But I'm leaving out that test, on the theory that
674 they can't possibly pass the tests below. */
675 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
676 || SYMBOL_CLASS (sym
) == LOC_STATIC
677 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
678 && SYMBOL_SECTION (sym
) >= 0)
680 SYMBOL_VALUE_ADDRESS (sym
) +=
681 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
683 #ifdef MIPS_EFI_SYMBOL_NAME
684 /* Relocate Extra Function Info for ecoff. */
686 else if (SYMBOL_CLASS (sym
) == LOC_CONST
687 && SYMBOL_DOMAIN (sym
) == LABEL_DOMAIN
688 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), MIPS_EFI_SYMBOL_NAME
) == 0)
689 ecoff_relocate_efi (sym
, ANOFFSET (delta
,
690 s
->block_line_section
));
698 struct partial_symtab
*p
;
700 ALL_OBJFILE_PSYMTABS (objfile
, p
)
702 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
703 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
708 struct partial_symbol
**psym
;
710 for (psym
= objfile
->global_psymbols
.list
;
711 psym
< objfile
->global_psymbols
.next
;
714 fixup_psymbol_section (*psym
, objfile
);
715 if (SYMBOL_SECTION (*psym
) >= 0)
716 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
717 SYMBOL_SECTION (*psym
));
719 for (psym
= objfile
->static_psymbols
.list
;
720 psym
< objfile
->static_psymbols
.next
;
723 fixup_psymbol_section (*psym
, objfile
);
724 if (SYMBOL_SECTION (*psym
) >= 0)
725 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
726 SYMBOL_SECTION (*psym
));
731 struct minimal_symbol
*msym
;
732 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
733 if (SYMBOL_SECTION (msym
) >= 0)
734 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
736 /* Relocating different sections by different amounts may cause the symbols
737 to be out of order. */
738 msymbols_sort (objfile
);
742 for (i
= 0; i
< objfile
->num_sections
; ++i
)
743 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
746 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
748 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
749 only as a fallback. */
750 struct obj_section
*s
;
751 s
= find_pc_section (objfile
->ei
.entry_point
);
753 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
755 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
759 struct obj_section
*s
;
762 abfd
= objfile
->obfd
;
764 ALL_OBJFILE_OSECTIONS (objfile
, s
)
766 int idx
= s
->the_bfd_section
->index
;
768 s
->addr
+= ANOFFSET (delta
, idx
);
769 s
->endaddr
+= ANOFFSET (delta
, idx
);
773 if (objfile
->ei
.entry_func_lowpc
!= INVALID_ENTRY_LOWPC
)
775 objfile
->ei
.entry_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
776 objfile
->ei
.entry_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
779 if (objfile
->ei
.entry_file_lowpc
!= INVALID_ENTRY_LOWPC
)
781 objfile
->ei
.entry_file_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
782 objfile
->ei
.entry_file_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
785 if (objfile
->ei
.main_func_lowpc
!= INVALID_ENTRY_LOWPC
)
787 objfile
->ei
.main_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
788 objfile
->ei
.main_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
791 /* Relocate breakpoints as necessary, after things are relocated. */
792 breakpoint_re_set ();
795 /* Many places in gdb want to test just to see if we have any partial
796 symbols available. This function returns zero if none are currently
797 available, nonzero otherwise. */
800 have_partial_symbols (void)
806 if (ofp
->psymtabs
!= NULL
)
814 /* Many places in gdb want to test just to see if we have any full
815 symbols available. This function returns zero if none are currently
816 available, nonzero otherwise. */
819 have_full_symbols (void)
825 if (ofp
->symtabs
!= NULL
)
834 /* This operations deletes all objfile entries that represent solibs that
835 weren't explicitly loaded by the user, via e.g., the add-symbol-file
839 objfile_purge_solibs (void)
841 struct objfile
*objf
;
842 struct objfile
*temp
;
844 ALL_OBJFILES_SAFE (objf
, temp
)
846 /* We assume that the solib package has been purged already, or will
849 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
855 /* Many places in gdb want to test just to see if we have any minimal
856 symbols available. This function returns zero if none are currently
857 available, nonzero otherwise. */
860 have_minimal_symbols (void)
866 if (ofp
->minimal_symbol_count
> 0)
874 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
876 /* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
877 of the corresponding symbol file in MTIME, try to open an existing file
878 with the name SYMSFILENAME and verify it is more recent than the base
879 file by checking it's timestamp against MTIME.
881 If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
883 If SYMSFILENAME does exist, but is out of date, we check to see if the
884 user has specified creation of a mapped file. If so, we don't issue
885 any warning message because we will be creating a new mapped file anyway,
886 overwriting the old one. If not, then we issue a warning message so that
887 the user will know why we aren't using this existing mapped symbol file.
888 In either case, we return -1.
890 If SYMSFILENAME does exist and is not out of date, but can't be opened for
891 some reason, then prints an appropriate system error message and returns -1.
893 Otherwise, returns the open file descriptor. */
896 open_existing_mapped_file (char *symsfilename
, long mtime
, int flags
)
901 if (stat (symsfilename
, &sbuf
) == 0)
903 if (sbuf
.st_mtime
< mtime
)
905 if (!(flags
& OBJF_MAPPED
))
907 warning ("mapped symbol file `%s' is out of date, ignored it",
911 else if ((fd
= open (symsfilename
, O_RDWR
)) < 0)
915 printf_unfiltered (error_pre_print
);
917 print_sys_errmsg (symsfilename
, errno
);
923 /* Look for a mapped symbol file that corresponds to FILENAME and is more
924 recent than MTIME. If MAPPED is nonzero, the user has asked that gdb
925 use a mapped symbol file for this file, so create a new one if one does
928 If found, then return an open file descriptor for the file, otherwise
931 This routine is responsible for implementing the policy that generates
932 the name of the mapped symbol file from the name of a file containing
933 symbols that gdb would like to read. Currently this policy is to append
934 ".syms" to the name of the file.
936 This routine is also responsible for implementing the policy that
937 determines where the mapped symbol file is found (the search path).
938 This policy is that when reading an existing mapped file, a file of
939 the correct name in the current directory takes precedence over a
940 file of the correct name in the same directory as the symbol file.
941 When creating a new mapped file, it is always created in the current
942 directory. This helps to minimize the chances of a user unknowingly
943 creating big mapped files in places like /bin and /usr/local/bin, and
944 allows a local copy to override a manually installed global copy (in
945 /bin for example). */
948 open_mapped_file (char *filename
, long mtime
, int flags
)
953 /* First try to open an existing file in the current directory, and
954 then try the directory where the symbol file is located. */
956 symsfilename
= concat ("./", lbasename (filename
), ".syms", (char *) NULL
);
957 if ((fd
= open_existing_mapped_file (symsfilename
, mtime
, flags
)) < 0)
959 xfree (symsfilename
);
960 symsfilename
= concat (filename
, ".syms", (char *) NULL
);
961 fd
= open_existing_mapped_file (symsfilename
, mtime
, flags
);
964 /* If we don't have an open file by now, then either the file does not
965 already exist, or the base file has changed since it was created. In
966 either case, if the user has specified use of a mapped file, then
967 create a new mapped file, truncating any existing one. If we can't
968 create one, print a system error message saying why we can't.
970 By default the file is rw for everyone, with the user's umask taking
971 care of turning off the permissions the user wants off. */
973 if ((fd
< 0) && (flags
& OBJF_MAPPED
))
975 xfree (symsfilename
);
976 symsfilename
= concat ("./", lbasename (filename
), ".syms",
978 if ((fd
= open (symsfilename
, O_RDWR
| O_CREAT
| O_TRUNC
, 0666)) < 0)
982 printf_unfiltered (error_pre_print
);
984 print_sys_errmsg (symsfilename
, errno
);
988 xfree (symsfilename
);
998 md
= mmalloc_attach (fd
, 0);
1001 mapto
= (CORE_ADDR
) mmalloc_getkey (md
, 1);
1002 md
= mmalloc_detach (md
);
1005 /* FIXME: should figure out why detach failed */
1008 else if (mapto
!= (CORE_ADDR
) NULL
)
1010 /* This mapping file needs to be remapped at "mapto" */
1011 md
= mmalloc_attach (fd
, mapto
);
1015 /* This is a freshly created mapping file. */
1016 mapto
= (CORE_ADDR
) mmalloc_findbase (20 * 1024 * 1024);
1019 /* To avoid reusing the freshly created mapping file, at the
1020 address selected by mmap, we must truncate it before trying
1021 to do an attach at the address we want. */
1023 md
= mmalloc_attach (fd
, mapto
);
1026 mmalloc_setkey (md
, 1, mapto
);
1034 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
1036 /* Returns a section whose range includes PC and SECTION,
1037 or NULL if none found. Note the distinction between the return type,
1038 struct obj_section (which is defined in gdb), and the input type
1039 struct sec (which is a bfd-defined data type). The obj_section
1040 contains a pointer to the bfd struct sec section. */
1042 struct obj_section
*
1043 find_pc_sect_section (CORE_ADDR pc
, struct sec
*section
)
1045 struct obj_section
*s
;
1046 struct objfile
*objfile
;
1048 ALL_OBJSECTIONS (objfile
, s
)
1049 if ((section
== 0 || section
== s
->the_bfd_section
) &&
1050 s
->addr
<= pc
&& pc
< s
->endaddr
)
1056 /* Returns a section whose range includes PC or NULL if none found.
1057 Backward compatibility, no section. */
1059 struct obj_section
*
1060 find_pc_section (CORE_ADDR pc
)
1062 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
1066 /* In SVR4, we recognize a trampoline by it's section name.
1067 That is, if the pc is in a section named ".plt" then we are in
1071 in_plt_section (CORE_ADDR pc
, char *name
)
1073 struct obj_section
*s
;
1076 s
= find_pc_section (pc
);
1079 && s
->the_bfd_section
->name
!= NULL
1080 && STREQ (s
->the_bfd_section
->name
, ".plt"));
1084 /* Return nonzero if NAME is in the import list of OBJFILE. Else
1088 is_in_import_list (char *name
, struct objfile
*objfile
)
1092 if (!objfile
|| !name
|| !*name
)
1095 for (i
= 0; i
< objfile
->import_list_size
; i
++)
1096 if (objfile
->import_list
[i
] && STREQ (name
, objfile
->import_list
[i
]))