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 "gdb_assert.h"
38 #include <sys/types.h>
41 #include "gdb_obstack.h"
42 #include "gdb_string.h"
45 #include "breakpoint.h"
47 #include "dictionary.h"
49 /* Prototypes for local functions */
51 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
55 static int open_existing_mapped_file (char *, long, int);
57 static int open_mapped_file (char *filename
, long mtime
, int flags
);
59 static void *map_to_file (int);
61 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
63 static void objfile_alloc_data (struct objfile
*objfile
);
64 static void objfile_free_data (struct objfile
*objfile
);
66 /* Externally visible variables that are owned by this module.
67 See declarations in objfile.h for more info. */
69 struct objfile
*object_files
; /* Linked list of all objfiles */
70 struct objfile
*current_objfile
; /* For symbol file being read in */
71 struct objfile
*symfile_objfile
; /* Main symbol table loaded from */
72 struct objfile
*rt_common_objfile
; /* For runtime common symbols */
74 int mapped_symbol_files
; /* Try to use mapped symbol files */
76 /* Locate all mappable sections of a BFD file.
77 objfile_p_char is a char * to get it through
78 bfd_map_over_sections; we cast it back to its proper type. */
80 #ifndef TARGET_KEEP_SECTION
81 #define TARGET_KEEP_SECTION(ASECT) 0
84 /* Called via bfd_map_over_sections to build up the section table that
85 the objfile references. The objfile contains pointers to the start
86 of the table (objfile->sections) and to the first location after
87 the end of the table (objfile->sections_end). */
90 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
93 struct objfile
*objfile
= (struct objfile
*) objfile_p_char
;
94 struct obj_section section
;
97 aflag
= bfd_get_section_flags (abfd
, asect
);
99 if (!(aflag
& SEC_ALLOC
) && !(TARGET_KEEP_SECTION (asect
)))
102 if (0 == bfd_section_size (abfd
, asect
))
105 section
.objfile
= objfile
;
106 section
.the_bfd_section
= asect
;
107 section
.ovly_mapped
= 0;
108 section
.addr
= bfd_section_vma (abfd
, asect
);
109 section
.endaddr
= section
.addr
+ bfd_section_size (abfd
, asect
);
110 obstack_grow (&objfile
->psymbol_obstack
, (char *) §ion
, sizeof (section
));
111 objfile
->sections_end
= (struct obj_section
*) (((unsigned long) objfile
->sections_end
) + 1);
114 /* Builds a section table for OBJFILE.
115 Returns 0 if OK, 1 on error (in which case bfd_error contains the
118 Note that while we are building the table, which goes into the
119 psymbol obstack, we hijack the sections_end pointer to instead hold
120 a count of the number of sections. When bfd_map_over_sections
121 returns, this count is used to compute the pointer to the end of
122 the sections table, which then overwrites the count.
124 Also note that the OFFSET and OVLY_MAPPED in each table entry
125 are initialized to zero.
127 Also note that if anything else writes to the psymbol obstack while
128 we are building the table, we're pretty much hosed. */
131 build_objfile_section_table (struct objfile
*objfile
)
133 /* objfile->sections can be already set when reading a mapped symbol
134 file. I believe that we do need to rebuild the section table in
135 this case (we rebuild other things derived from the bfd), but we
136 can't free the old one (it's in the psymbol_obstack). So we just
137 waste some memory. */
139 objfile
->sections_end
= 0;
140 bfd_map_over_sections (objfile
->obfd
, add_to_objfile_sections
, (char *) objfile
);
141 objfile
->sections
= (struct obj_section
*)
142 obstack_finish (&objfile
->psymbol_obstack
);
143 objfile
->sections_end
= objfile
->sections
+ (unsigned long) objfile
->sections_end
;
147 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
148 allocate a new objfile struct, fill it in as best we can, link it
149 into the list of all known objfiles, and return a pointer to the
152 The FLAGS word contains various bits (OBJF_*) that can be taken as
153 requests for specific operations, like trying to open a mapped
154 version of the objfile (OBJF_MAPPED). Other bits like
155 OBJF_SHARED are simply copied through to the new objfile flags
158 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
159 by jv-lang.c, to create an artificial objfile used to hold
160 information about dynamically-loaded Java classes. Unfortunately,
161 that branch of this function doesn't get tested very frequently, so
162 it's prone to breakage. (E.g. at one time the name was set to NULL
163 in that situation, which broke a loop over all names in the dynamic
164 library loader.) If you change this function, please try to leave
165 things in a consistent state even if abfd is NULL. */
168 allocate_objfile (bfd
*abfd
, int flags
)
170 struct objfile
*objfile
= NULL
;
171 struct objfile
*last_one
= NULL
;
173 if (mapped_symbol_files
)
174 flags
|= OBJF_MAPPED
;
176 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
180 /* If we can support mapped symbol files, try to open/reopen the
181 mapped file that corresponds to the file from which we wish to
182 read symbols. If the objfile is to be mapped, we must malloc
183 the structure itself using the mmap version, and arrange that
184 all memory allocation for the objfile uses the mmap routines.
185 If we are reusing an existing mapped file, from which we get
186 our objfile pointer, we have to make sure that we update the
187 pointers to the alloc/free functions in the obstack, in case
188 these functions have moved within the current gdb. */
192 fd
= open_mapped_file (bfd_get_filename (abfd
), bfd_get_mtime (abfd
),
198 if ((md
= map_to_file (fd
)) == NULL
)
202 else if ((objfile
= (struct objfile
*) mmalloc_getkey (md
, 0)) != NULL
)
204 /* Update memory corruption handler function addresses. */
208 /* Update pointers to functions to *our* copies */
209 if (objfile
->demangled_names_hash
)
210 htab_set_functions_ex
211 (objfile
->demangled_names_hash
, htab_hash_string
,
212 (int (*) (const void *, const void *)) streq
, NULL
,
213 objfile
->md
, xmcalloc
, xmfree
);
214 obstack_chunkfun (&objfile
->psymbol_cache
.cache
, xmmalloc
);
215 obstack_freefun (&objfile
->psymbol_cache
.cache
, xmfree
);
216 obstack_chunkfun (&objfile
->macro_cache
.cache
, xmmalloc
);
217 obstack_freefun (&objfile
->macro_cache
.cache
, xmfree
);
218 obstack_chunkfun (&objfile
->psymbol_obstack
, xmmalloc
);
219 obstack_freefun (&objfile
->psymbol_obstack
, xmfree
);
220 obstack_chunkfun (&objfile
->symbol_obstack
, xmmalloc
);
221 obstack_freefun (&objfile
->symbol_obstack
, xmfree
);
222 obstack_chunkfun (&objfile
->type_obstack
, xmmalloc
);
223 obstack_freefun (&objfile
->type_obstack
, xmfree
);
224 /* If already in objfile list, unlink it. */
225 unlink_objfile (objfile
);
226 /* Forget things specific to a particular gdb, may have changed. */
232 /* Set up to detect internal memory corruption. MUST be
233 done before the first malloc. See comments in
234 init_malloc() and mmcheck(). */
238 objfile
= (struct objfile
*)
239 xmmalloc (md
, sizeof (struct objfile
));
240 memset (objfile
, 0, sizeof (struct objfile
));
243 objfile
->flags
|= OBJF_MAPPED
;
244 mmalloc_setkey (objfile
->md
, 0, objfile
);
245 obstack_specify_allocation_with_arg (&objfile
->psymbol_cache
.cache
,
246 0, 0, xmmalloc
, xmfree
,
248 obstack_specify_allocation_with_arg (&objfile
->macro_cache
.cache
,
249 0, 0, xmmalloc
, xmfree
,
251 obstack_specify_allocation_with_arg (&objfile
->psymbol_obstack
,
252 0, 0, xmmalloc
, xmfree
,
254 obstack_specify_allocation_with_arg (&objfile
->symbol_obstack
,
255 0, 0, xmmalloc
, xmfree
,
257 obstack_specify_allocation_with_arg (&objfile
->type_obstack
,
258 0, 0, xmmalloc
, xmfree
,
263 if ((flags
& OBJF_MAPPED
) && (objfile
== NULL
))
265 warning ("symbol table for '%s' will not be mapped",
266 bfd_get_filename (abfd
));
267 flags
&= ~OBJF_MAPPED
;
270 #else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
272 if (flags
& OBJF_MAPPED
)
274 warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
276 /* Turn off the global flag so we don't try to do mapped symbol tables
277 any more, which shuts up gdb unless the user specifically gives the
278 "mapped" keyword again. */
280 mapped_symbol_files
= 0;
281 flags
&= ~OBJF_MAPPED
;
284 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
286 /* If we don't support mapped symbol files, didn't ask for the file to be
287 mapped, or failed to open the mapped file for some reason, then revert
288 back to an unmapped objfile. */
292 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
293 memset (objfile
, 0, sizeof (struct objfile
));
295 objfile
->psymbol_cache
= bcache_xmalloc ();
296 objfile
->macro_cache
= bcache_xmalloc ();
297 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0, xmalloc
,
299 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0, xmalloc
,
301 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0, xmalloc
,
303 flags
&= ~OBJF_MAPPED
;
305 terminate_minimal_symbol_table (objfile
);
308 objfile_alloc_data (objfile
);
310 /* Update the per-objfile information that comes from the bfd, ensuring
311 that any data that is reference is saved in the per-objfile data
314 objfile
->obfd
= abfd
;
315 if (objfile
->name
!= NULL
)
317 xmfree (objfile
->md
, objfile
->name
);
321 objfile
->name
= mstrsave (objfile
->md
, bfd_get_filename (abfd
));
322 objfile
->mtime
= bfd_get_mtime (abfd
);
324 /* Build section table. */
326 if (build_objfile_section_table (objfile
))
328 error ("Can't find the file sections in `%s': %s",
329 objfile
->name
, bfd_errmsg (bfd_get_error ()));
334 objfile
->name
= mstrsave (objfile
->md
, "<<anonymous objfile>>");
337 /* Initialize the section indexes for this objfile, so that we can
338 later detect if they are used w/o being properly assigned to. */
340 objfile
->sect_index_text
= -1;
341 objfile
->sect_index_data
= -1;
342 objfile
->sect_index_bss
= -1;
343 objfile
->sect_index_rodata
= -1;
345 /* We don't yet have a C++-specific namespace symtab. */
347 objfile
->cp_namespace_symtab
= NULL
;
349 /* Add this file onto the tail of the linked list of other such files. */
351 objfile
->next
= NULL
;
352 if (object_files
== NULL
)
353 object_files
= objfile
;
356 for (last_one
= object_files
;
358 last_one
= last_one
->next
);
359 last_one
->next
= objfile
;
362 /* Save passed in flag bits. */
363 objfile
->flags
|= flags
;
369 /* Create the terminating entry of OBJFILE's minimal symbol table.
370 If OBJFILE->msymbols is zero, allocate a single entry from
371 OBJFILE->symbol_obstack; otherwise, just initialize
372 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
374 terminate_minimal_symbol_table (struct objfile
*objfile
)
376 if (! objfile
->msymbols
)
377 objfile
->msymbols
= ((struct minimal_symbol
*)
378 obstack_alloc (&objfile
->symbol_obstack
,
379 sizeof (objfile
->msymbols
[0])));
382 struct minimal_symbol
*m
383 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
385 memset (m
, 0, sizeof (*m
));
386 DEPRECATED_SYMBOL_NAME (m
) = NULL
;
387 SYMBOL_VALUE_ADDRESS (m
) = 0;
388 MSYMBOL_INFO (m
) = NULL
;
389 MSYMBOL_TYPE (m
) = mst_unknown
;
390 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
395 /* Put one object file before a specified on in the global list.
396 This can be used to make sure an object file is destroyed before
397 another when using ALL_OBJFILES_SAFE to free all objfiles. */
399 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
401 struct objfile
**objp
;
403 unlink_objfile (objfile
);
405 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
407 if (*objp
== before_this
)
409 objfile
->next
= *objp
;
415 internal_error (__FILE__
, __LINE__
,
416 "put_objfile_before: before objfile not in list");
419 /* Put OBJFILE at the front of the list. */
422 objfile_to_front (struct objfile
*objfile
)
424 struct objfile
**objp
;
425 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
427 if (*objp
== objfile
)
429 /* Unhook it from where it is. */
430 *objp
= objfile
->next
;
431 /* Put it in the front. */
432 objfile
->next
= object_files
;
433 object_files
= objfile
;
439 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
442 It is not a bug, or error, to call this function if OBJFILE is not known
443 to be in the current list. This is done in the case of mapped objfiles,
444 for example, just to ensure that the mapped objfile doesn't appear twice
445 in the list. Since the list is threaded, linking in a mapped objfile
446 twice would create a circular list.
448 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
449 unlinking it, just to ensure that we have completely severed any linkages
450 between the OBJFILE and the list. */
453 unlink_objfile (struct objfile
*objfile
)
455 struct objfile
**objpp
;
457 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
459 if (*objpp
== objfile
)
461 *objpp
= (*objpp
)->next
;
462 objfile
->next
= NULL
;
467 internal_error (__FILE__
, __LINE__
,
468 "unlink_objfile: objfile already unlinked");
472 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
473 that as much as possible is allocated on the symbol_obstack and
474 psymbol_obstack, so that the memory can be efficiently freed.
476 Things which we do NOT free because they are not in malloc'd memory
477 or not in memory specific to the objfile include:
481 FIXME: If the objfile is using reusable symbol information (via mmalloc),
482 then we need to take into account the fact that more than one process
483 may be using the symbol information at the same time (when mmalloc is
484 extended to support cooperative locking). When more than one process
485 is using the mapped symbol info, we need to be more careful about when
486 we free objects in the reusable area. */
489 free_objfile (struct objfile
*objfile
)
491 if (objfile
->separate_debug_objfile
)
493 free_objfile (objfile
->separate_debug_objfile
);
496 if (objfile
->separate_debug_objfile_backlink
)
498 /* We freed the separate debug file, make sure the base objfile
499 doesn't reference it. */
500 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
503 /* First do any symbol file specific actions required when we are
504 finished with a particular symbol file. Note that if the objfile
505 is using reusable symbol information (via mmalloc) then each of
506 these routines is responsible for doing the correct thing, either
507 freeing things which are valid only during this particular gdb
508 execution, or leaving them to be reused during the next one. */
510 if (objfile
->sf
!= NULL
)
512 (*objfile
->sf
->sym_finish
) (objfile
);
515 /* We always close the bfd. */
517 if (objfile
->obfd
!= NULL
)
519 char *name
= bfd_get_filename (objfile
->obfd
);
520 if (!bfd_close (objfile
->obfd
))
521 warning ("cannot close \"%s\": %s",
522 name
, bfd_errmsg (bfd_get_error ()));
526 /* Remove it from the chain of all objfiles. */
528 unlink_objfile (objfile
);
530 /* If we are going to free the runtime common objfile, mark it
533 if (objfile
== rt_common_objfile
)
534 rt_common_objfile
= NULL
;
536 /* Before the symbol table code was redone to make it easier to
537 selectively load and remove information particular to a specific
538 linkage unit, gdb used to do these things whenever the monolithic
539 symbol table was blown away. How much still needs to be done
540 is unknown, but we play it safe for now and keep each action until
541 it is shown to be no longer needed. */
543 /* I *think* all our callers call clear_symtab_users. If so, no need
544 to call this here. */
545 clear_pc_function_cache ();
547 /* The last thing we do is free the objfile struct itself for the
548 non-reusable case, or detach from the mapped file for the
549 reusable case. Note that the mmalloc_detach or the xmfree() is
550 the last thing we can do with this objfile. */
552 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
554 if (objfile
->flags
& OBJF_MAPPED
)
556 /* Remember the fd so we can close it. We can't close it before
557 doing the detach, and after the detach the objfile is gone. */
560 mmfd
= objfile
->mmfd
;
561 mmalloc_detach (objfile
->md
);
566 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
568 /* If we still have an objfile, then either we don't support reusable
569 objfiles or this one was not reusable. So free it normally. */
573 objfile_free_data (objfile
);
574 if (objfile
->name
!= NULL
)
576 xmfree (objfile
->md
, objfile
->name
);
578 if (objfile
->global_psymbols
.list
)
579 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
580 if (objfile
->static_psymbols
.list
)
581 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
582 /* Free the obstacks for non-reusable objfiles */
583 bcache_xfree (objfile
->psymbol_cache
);
584 bcache_xfree (objfile
->macro_cache
);
585 if (objfile
->demangled_names_hash
)
586 htab_delete (objfile
->demangled_names_hash
);
587 obstack_free (&objfile
->psymbol_obstack
, 0);
588 obstack_free (&objfile
->symbol_obstack
, 0);
589 obstack_free (&objfile
->type_obstack
, 0);
590 xmfree (objfile
->md
, objfile
);
596 do_free_objfile_cleanup (void *obj
)
602 make_cleanup_free_objfile (struct objfile
*obj
)
604 return make_cleanup (do_free_objfile_cleanup
, obj
);
607 /* Free all the object files at once and clean up their users. */
610 free_all_objfiles (void)
612 struct objfile
*objfile
, *temp
;
614 ALL_OBJFILES_SAFE (objfile
, temp
)
616 free_objfile (objfile
);
618 clear_symtab_users ();
621 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
622 entries in new_offsets. */
624 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
626 struct section_offsets
*delta
=
627 ((struct section_offsets
*)
628 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
632 int something_changed
= 0;
633 for (i
= 0; i
< objfile
->num_sections
; ++i
)
636 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
637 if (ANOFFSET (delta
, i
) != 0)
638 something_changed
= 1;
640 if (!something_changed
)
644 /* OK, get all the symtabs. */
648 ALL_OBJFILE_SYMTABS (objfile
, s
)
651 struct blockvector
*bv
;
654 /* First the line table. */
658 for (i
= 0; i
< l
->nitems
; ++i
)
659 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
662 /* Don't relocate a shared blockvector more than once. */
666 bv
= BLOCKVECTOR (s
);
667 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
671 struct dict_iterator iter
;
673 b
= BLOCKVECTOR_BLOCK (bv
, i
);
674 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
675 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
677 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
679 fixup_symbol_section (sym
, objfile
);
681 /* The RS6000 code from which this was taken skipped
682 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
683 But I'm leaving out that test, on the theory that
684 they can't possibly pass the tests below. */
685 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
686 || SYMBOL_CLASS (sym
) == LOC_STATIC
687 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
688 && SYMBOL_SECTION (sym
) >= 0)
690 SYMBOL_VALUE_ADDRESS (sym
) +=
691 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
693 #ifdef MIPS_EFI_SYMBOL_NAME
694 /* Relocate Extra Function Info for ecoff. */
696 else if (SYMBOL_CLASS (sym
) == LOC_CONST
697 && SYMBOL_DOMAIN (sym
) == LABEL_DOMAIN
698 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), MIPS_EFI_SYMBOL_NAME
) == 0)
699 ecoff_relocate_efi (sym
, ANOFFSET (delta
,
700 s
->block_line_section
));
708 struct partial_symtab
*p
;
710 ALL_OBJFILE_PSYMTABS (objfile
, p
)
712 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
713 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
718 struct partial_symbol
**psym
;
720 for (psym
= objfile
->global_psymbols
.list
;
721 psym
< objfile
->global_psymbols
.next
;
724 fixup_psymbol_section (*psym
, objfile
);
725 if (SYMBOL_SECTION (*psym
) >= 0)
726 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
727 SYMBOL_SECTION (*psym
));
729 for (psym
= objfile
->static_psymbols
.list
;
730 psym
< objfile
->static_psymbols
.next
;
733 fixup_psymbol_section (*psym
, objfile
);
734 if (SYMBOL_SECTION (*psym
) >= 0)
735 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
736 SYMBOL_SECTION (*psym
));
741 struct minimal_symbol
*msym
;
742 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
743 if (SYMBOL_SECTION (msym
) >= 0)
744 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
746 /* Relocating different sections by different amounts may cause the symbols
747 to be out of order. */
748 msymbols_sort (objfile
);
752 for (i
= 0; i
< objfile
->num_sections
; ++i
)
753 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
756 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
758 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
759 only as a fallback. */
760 struct obj_section
*s
;
761 s
= find_pc_section (objfile
->ei
.entry_point
);
763 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
765 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
769 struct obj_section
*s
;
772 abfd
= objfile
->obfd
;
774 ALL_OBJFILE_OSECTIONS (objfile
, s
)
776 int idx
= s
->the_bfd_section
->index
;
778 s
->addr
+= ANOFFSET (delta
, idx
);
779 s
->endaddr
+= ANOFFSET (delta
, idx
);
783 if (objfile
->ei
.entry_func_lowpc
!= INVALID_ENTRY_LOWPC
)
785 objfile
->ei
.entry_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
786 objfile
->ei
.entry_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
789 if (objfile
->ei
.deprecated_entry_file_lowpc
!= INVALID_ENTRY_LOWPC
)
791 objfile
->ei
.deprecated_entry_file_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
792 objfile
->ei
.deprecated_entry_file_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
795 if (objfile
->ei
.main_func_lowpc
!= INVALID_ENTRY_LOWPC
)
797 objfile
->ei
.main_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
798 objfile
->ei
.main_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
801 /* Relocate breakpoints as necessary, after things are relocated. */
802 breakpoint_re_set ();
805 /* Many places in gdb want to test just to see if we have any partial
806 symbols available. This function returns zero if none are currently
807 available, nonzero otherwise. */
810 have_partial_symbols (void)
816 if (ofp
->psymtabs
!= NULL
)
824 /* Many places in gdb want to test just to see if we have any full
825 symbols available. This function returns zero if none are currently
826 available, nonzero otherwise. */
829 have_full_symbols (void)
835 if (ofp
->symtabs
!= NULL
)
844 /* This operations deletes all objfile entries that represent solibs that
845 weren't explicitly loaded by the user, via e.g., the add-symbol-file
849 objfile_purge_solibs (void)
851 struct objfile
*objf
;
852 struct objfile
*temp
;
854 ALL_OBJFILES_SAFE (objf
, temp
)
856 /* We assume that the solib package has been purged already, or will
859 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
865 /* Many places in gdb want to test just to see if we have any minimal
866 symbols available. This function returns zero if none are currently
867 available, nonzero otherwise. */
870 have_minimal_symbols (void)
876 if (ofp
->minimal_symbol_count
> 0)
884 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
886 /* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
887 of the corresponding symbol file in MTIME, try to open an existing file
888 with the name SYMSFILENAME and verify it is more recent than the base
889 file by checking it's timestamp against MTIME.
891 If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
893 If SYMSFILENAME does exist, but is out of date, we check to see if the
894 user has specified creation of a mapped file. If so, we don't issue
895 any warning message because we will be creating a new mapped file anyway,
896 overwriting the old one. If not, then we issue a warning message so that
897 the user will know why we aren't using this existing mapped symbol file.
898 In either case, we return -1.
900 If SYMSFILENAME does exist and is not out of date, but can't be opened for
901 some reason, then prints an appropriate system error message and returns -1.
903 Otherwise, returns the open file descriptor. */
906 open_existing_mapped_file (char *symsfilename
, long mtime
, int flags
)
911 if (stat (symsfilename
, &sbuf
) == 0)
913 if (sbuf
.st_mtime
< mtime
)
915 if (!(flags
& OBJF_MAPPED
))
917 warning ("mapped symbol file `%s' is out of date, ignored it",
921 else if ((fd
= open (symsfilename
, O_RDWR
)) < 0)
925 printf_unfiltered (error_pre_print
);
927 print_sys_errmsg (symsfilename
, errno
);
933 /* Look for a mapped symbol file that corresponds to FILENAME and is more
934 recent than MTIME. If MAPPED is nonzero, the user has asked that gdb
935 use a mapped symbol file for this file, so create a new one if one does
938 If found, then return an open file descriptor for the file, otherwise
941 This routine is responsible for implementing the policy that generates
942 the name of the mapped symbol file from the name of a file containing
943 symbols that gdb would like to read. Currently this policy is to append
944 ".syms" to the name of the file.
946 This routine is also responsible for implementing the policy that
947 determines where the mapped symbol file is found (the search path).
948 This policy is that when reading an existing mapped file, a file of
949 the correct name in the current directory takes precedence over a
950 file of the correct name in the same directory as the symbol file.
951 When creating a new mapped file, it is always created in the current
952 directory. This helps to minimize the chances of a user unknowingly
953 creating big mapped files in places like /bin and /usr/local/bin, and
954 allows a local copy to override a manually installed global copy (in
955 /bin for example). */
958 open_mapped_file (char *filename
, long mtime
, int flags
)
963 /* First try to open an existing file in the current directory, and
964 then try the directory where the symbol file is located. */
966 symsfilename
= concat ("./", lbasename (filename
), ".syms", (char *) NULL
);
967 if ((fd
= open_existing_mapped_file (symsfilename
, mtime
, flags
)) < 0)
969 xfree (symsfilename
);
970 symsfilename
= concat (filename
, ".syms", (char *) NULL
);
971 fd
= open_existing_mapped_file (symsfilename
, mtime
, flags
);
974 /* If we don't have an open file by now, then either the file does not
975 already exist, or the base file has changed since it was created. In
976 either case, if the user has specified use of a mapped file, then
977 create a new mapped file, truncating any existing one. If we can't
978 create one, print a system error message saying why we can't.
980 By default the file is rw for everyone, with the user's umask taking
981 care of turning off the permissions the user wants off. */
983 if ((fd
< 0) && (flags
& OBJF_MAPPED
))
985 xfree (symsfilename
);
986 symsfilename
= concat ("./", lbasename (filename
), ".syms",
988 if ((fd
= open (symsfilename
, O_RDWR
| O_CREAT
| O_TRUNC
, 0666)) < 0)
992 printf_unfiltered (error_pre_print
);
994 print_sys_errmsg (symsfilename
, errno
);
998 xfree (symsfilename
);
1003 map_to_file (int fd
)
1008 md
= mmalloc_attach (fd
, 0);
1011 mapto
= (CORE_ADDR
) mmalloc_getkey (md
, 1);
1012 md
= mmalloc_detach (md
);
1015 /* FIXME: should figure out why detach failed */
1018 else if (mapto
!= (CORE_ADDR
) NULL
)
1020 /* This mapping file needs to be remapped at "mapto" */
1021 md
= mmalloc_attach (fd
, mapto
);
1025 /* This is a freshly created mapping file. */
1026 mapto
= (CORE_ADDR
) mmalloc_findbase (20 * 1024 * 1024);
1029 /* To avoid reusing the freshly created mapping file, at the
1030 address selected by mmap, we must truncate it before trying
1031 to do an attach at the address we want. */
1033 md
= mmalloc_attach (fd
, mapto
);
1036 mmalloc_setkey (md
, 1, mapto
);
1044 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
1046 /* Returns a section whose range includes PC and SECTION, or NULL if
1047 none found. Note the distinction between the return type, struct
1048 obj_section (which is defined in gdb), and the input type "struct
1049 bfd_section" (which is a bfd-defined data type). The obj_section
1050 contains a pointer to the "struct bfd_section". */
1052 struct obj_section
*
1053 find_pc_sect_section (CORE_ADDR pc
, struct bfd_section
*section
)
1055 struct obj_section
*s
;
1056 struct objfile
*objfile
;
1058 ALL_OBJSECTIONS (objfile
, s
)
1059 if ((section
== 0 || section
== s
->the_bfd_section
) &&
1060 s
->addr
<= pc
&& pc
< s
->endaddr
)
1066 /* Returns a section whose range includes PC or NULL if none found.
1067 Backward compatibility, no section. */
1069 struct obj_section
*
1070 find_pc_section (CORE_ADDR pc
)
1072 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
1076 /* In SVR4, we recognize a trampoline by it's section name.
1077 That is, if the pc is in a section named ".plt" then we are in
1081 in_plt_section (CORE_ADDR pc
, char *name
)
1083 struct obj_section
*s
;
1086 s
= find_pc_section (pc
);
1089 && s
->the_bfd_section
->name
!= NULL
1090 && STREQ (s
->the_bfd_section
->name
, ".plt"));
1094 /* Return nonzero if NAME is in the import list of OBJFILE. Else
1098 is_in_import_list (char *name
, struct objfile
*objfile
)
1102 if (!objfile
|| !name
|| !*name
)
1105 for (i
= 0; i
< objfile
->import_list_size
; i
++)
1106 if (objfile
->import_list
[i
] && STREQ (name
, objfile
->import_list
[i
]))
1112 /* Keep a registry of per-objfile data-pointers required by other GDB
1120 struct objfile_data_registration
1122 struct objfile_data
*data
;
1123 struct objfile_data_registration
*next
;
1126 struct objfile_data_registry
1128 struct objfile_data_registration
*registrations
;
1129 unsigned num_registrations
;
1132 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
1134 const struct objfile_data
*
1135 register_objfile_data (void)
1137 struct objfile_data_registration
**curr
;
1139 /* Append new registration. */
1140 for (curr
= &objfile_data_registry
.registrations
;
1141 *curr
!= NULL
; curr
= &(*curr
)->next
);
1143 *curr
= XMALLOC (struct objfile_data_registration
);
1144 (*curr
)->next
= NULL
;
1145 (*curr
)->data
= XMALLOC (struct objfile_data
);
1146 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
1148 return (*curr
)->data
;
1152 objfile_alloc_data (struct objfile
*objfile
)
1154 gdb_assert (objfile
->data
== NULL
);
1155 objfile
->num_data
= objfile_data_registry
.num_registrations
;
1156 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
1160 objfile_free_data (struct objfile
*objfile
)
1162 gdb_assert (objfile
->data
!= NULL
);
1163 xfree (objfile
->data
);
1164 objfile
->data
= NULL
;
1168 clear_objfile_data (struct objfile
*objfile
)
1170 gdb_assert (objfile
->data
!= NULL
);
1171 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
1175 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
1178 gdb_assert (data
->index
< objfile
->num_data
);
1179 objfile
->data
[data
->index
] = value
;
1183 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
1185 gdb_assert (data
->index
< objfile
->num_data
);
1186 return objfile
->data
[data
->index
];