1 /* GDB routines for manipulating objfiles.
2 Copyright 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This file contains support routines for creating, manipulating, and
23 destroying objfile structures. */
26 #include "bfd.h" /* Binary File Description */
30 #include "gdb-stabs.h"
33 #include <sys/types.h>
37 #include "gdb_string.h"
39 #include "breakpoint.h"
41 /* Prototypes for local functions */
43 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
45 static int open_existing_mapped_file (char *, long, int);
47 static int open_mapped_file (char *filename
, long mtime
, int flags
);
49 static PTR
map_to_file (int);
51 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
53 static void add_to_objfile_sections (bfd
*, sec_ptr
, PTR
);
55 /* Externally visible variables that are owned by this module.
56 See declarations in objfile.h for more info. */
58 struct objfile
*object_files
; /* Linked list of all objfiles */
59 struct objfile
*current_objfile
; /* For symbol file being read in */
60 struct objfile
*symfile_objfile
; /* Main symbol table loaded from */
61 struct objfile
*rt_common_objfile
; /* For runtime common symbols */
63 int mapped_symbol_files
; /* Try to use mapped symbol files */
65 /* Locate all mappable sections of a BFD file.
66 objfile_p_char is a char * to get it through
67 bfd_map_over_sections; we cast it back to its proper type. */
69 #ifndef TARGET_KEEP_SECTION
70 #define TARGET_KEEP_SECTION(ASECT) 0
73 /* Called via bfd_map_over_sections to build up the section table that
74 the objfile references. The objfile contains pointers to the start
75 of the table (objfile->sections) and to the first location after
76 the end of the table (objfile->sections_end). */
79 add_to_objfile_sections (abfd
, asect
, objfile_p_char
)
84 struct objfile
*objfile
= (struct objfile
*) objfile_p_char
;
85 struct obj_section section
;
88 aflag
= bfd_get_section_flags (abfd
, asect
);
90 if (!(aflag
& SEC_ALLOC
) && !(TARGET_KEEP_SECTION (asect
)))
93 if (0 == bfd_section_size (abfd
, asect
))
96 section
.objfile
= objfile
;
97 section
.the_bfd_section
= asect
;
98 section
.ovly_mapped
= 0;
99 section
.addr
= bfd_section_vma (abfd
, asect
);
100 section
.endaddr
= section
.addr
+ bfd_section_size (abfd
, asect
);
101 obstack_grow (&objfile
->psymbol_obstack
, (char *) §ion
, sizeof (section
));
102 objfile
->sections_end
= (struct obj_section
*) (((unsigned long) objfile
->sections_end
) + 1);
105 /* Builds a section table for OBJFILE.
106 Returns 0 if OK, 1 on error (in which case bfd_error contains the
109 Note that while we are building the table, which goes into the
110 psymbol obstack, we hijack the sections_end pointer to instead hold
111 a count of the number of sections. When bfd_map_over_sections
112 returns, this count is used to compute the pointer to the end of
113 the sections table, which then overwrites the count.
115 Also note that the OFFSET and OVLY_MAPPED in each table entry
116 are initialized to zero.
118 Also note that if anything else writes to the psymbol obstack while
119 we are building the table, we're pretty much hosed. */
122 build_objfile_section_table (objfile
)
123 struct objfile
*objfile
;
125 /* objfile->sections can be already set when reading a mapped symbol
126 file. I believe that we do need to rebuild the section table in
127 this case (we rebuild other things derived from the bfd), but we
128 can't free the old one (it's in the psymbol_obstack). So we just
129 waste some memory. */
131 objfile
->sections_end
= 0;
132 bfd_map_over_sections (objfile
->obfd
, add_to_objfile_sections
, (char *) objfile
);
133 objfile
->sections
= (struct obj_section
*)
134 obstack_finish (&objfile
->psymbol_obstack
);
135 objfile
->sections_end
= objfile
->sections
+ (unsigned long) objfile
->sections_end
;
139 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
140 allocate a new objfile struct, fill it in as best we can, link it
141 into the list of all known objfiles, and return a pointer to the
144 The FLAGS word contains various bits (OBJF_*) that can be taken as
145 requests for specific operations, like trying to open a mapped
146 version of the objfile (OBJF_MAPPED). Other bits like
147 OBJF_SHARED are simply copied through to the new objfile flags
151 allocate_objfile (abfd
, flags
)
155 struct objfile
*objfile
= NULL
;
156 struct objfile
*last_one
= NULL
;
158 if (mapped_symbol_files
)
159 flags
|= OBJF_MAPPED
;
161 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
165 /* If we can support mapped symbol files, try to open/reopen the
166 mapped file that corresponds to the file from which we wish to
167 read symbols. If the objfile is to be mapped, we must malloc
168 the structure itself using the mmap version, and arrange that
169 all memory allocation for the objfile uses the mmap routines.
170 If we are reusing an existing mapped file, from which we get
171 our objfile pointer, we have to make sure that we update the
172 pointers to the alloc/free functions in the obstack, in case
173 these functions have moved within the current gdb. */
177 fd
= open_mapped_file (bfd_get_filename (abfd
), bfd_get_mtime (abfd
),
183 if ((md
= map_to_file (fd
)) == NULL
)
187 else if ((objfile
= (struct objfile
*) mmalloc_getkey (md
, 0)) != NULL
)
189 /* Update memory corruption handler function addresses. */
193 /* Update pointers to functions to *our* copies */
194 obstack_chunkfun (&objfile
->psymbol_cache
.cache
, xmmalloc
);
195 obstack_freefun (&objfile
->psymbol_cache
.cache
, mfree
);
196 obstack_chunkfun (&objfile
->psymbol_obstack
, xmmalloc
);
197 obstack_freefun (&objfile
->psymbol_obstack
, mfree
);
198 obstack_chunkfun (&objfile
->symbol_obstack
, xmmalloc
);
199 obstack_freefun (&objfile
->symbol_obstack
, mfree
);
200 obstack_chunkfun (&objfile
->type_obstack
, xmmalloc
);
201 obstack_freefun (&objfile
->type_obstack
, mfree
);
202 /* If already in objfile list, unlink it. */
203 unlink_objfile (objfile
);
204 /* Forget things specific to a particular gdb, may have changed. */
210 /* Set up to detect internal memory corruption. MUST be
211 done before the first malloc. See comments in
212 init_malloc() and mmcheck(). */
216 objfile
= (struct objfile
*)
217 xmmalloc (md
, sizeof (struct objfile
));
218 memset (objfile
, 0, sizeof (struct objfile
));
221 objfile
->flags
|= OBJF_MAPPED
;
222 mmalloc_setkey (objfile
->md
, 0, objfile
);
223 obstack_specify_allocation_with_arg (&objfile
->psymbol_cache
.cache
,
224 0, 0, xmmalloc
, mfree
,
226 obstack_specify_allocation_with_arg (&objfile
->psymbol_obstack
,
227 0, 0, xmmalloc
, mfree
,
229 obstack_specify_allocation_with_arg (&objfile
->symbol_obstack
,
230 0, 0, xmmalloc
, mfree
,
232 obstack_specify_allocation_with_arg (&objfile
->type_obstack
,
233 0, 0, xmmalloc
, mfree
,
238 if ((flags
& OBJF_MAPPED
) && (objfile
== NULL
))
240 warning ("symbol table for '%s' will not be mapped",
241 bfd_get_filename (abfd
));
242 flags
&= ~OBJF_MAPPED
;
245 #else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
247 if (flags
& OBJF_MAPPED
)
249 warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
251 /* Turn off the global flag so we don't try to do mapped symbol tables
252 any more, which shuts up gdb unless the user specifically gives the
253 "mapped" keyword again. */
255 mapped_symbol_files
= 0;
256 flags
&= ~OBJF_MAPPED
;
259 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
261 /* If we don't support mapped symbol files, didn't ask for the file to be
262 mapped, or failed to open the mapped file for some reason, then revert
263 back to an unmapped objfile. */
267 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
268 memset (objfile
, 0, sizeof (struct objfile
));
270 obstack_specify_allocation (&objfile
->psymbol_cache
.cache
, 0, 0,
272 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0, xmalloc
,
274 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0, xmalloc
,
276 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0, xmalloc
,
278 flags
&= ~OBJF_MAPPED
;
281 /* Update the per-objfile information that comes from the bfd, ensuring
282 that any data that is reference is saved in the per-objfile data
285 objfile
->obfd
= abfd
;
286 if (objfile
->name
!= NULL
)
288 mfree (objfile
->md
, objfile
->name
);
292 objfile
->name
= mstrsave (objfile
->md
, bfd_get_filename (abfd
));
293 objfile
->mtime
= bfd_get_mtime (abfd
);
295 /* Build section table. */
297 if (build_objfile_section_table (objfile
))
299 error ("Can't find the file sections in `%s': %s",
300 objfile
->name
, bfd_errmsg (bfd_get_error ()));
304 /* Initialize the section indexes for this objfile, so that we can
305 later detect if they are used w/o being properly assigned to. */
307 objfile
->sect_index_text
= -1;
308 objfile
->sect_index_data
= -1;
309 objfile
->sect_index_bss
= -1;
310 objfile
->sect_index_rodata
= -1;
312 /* Add this file onto the tail of the linked list of other such files. */
314 objfile
->next
= NULL
;
315 if (object_files
== NULL
)
316 object_files
= objfile
;
319 for (last_one
= object_files
;
321 last_one
= last_one
->next
);
322 last_one
->next
= objfile
;
325 /* Save passed in flag bits. */
326 objfile
->flags
|= flags
;
331 /* Put OBJFILE at the front of the list. */
334 objfile_to_front (objfile
)
335 struct objfile
*objfile
;
337 struct objfile
**objp
;
338 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
340 if (*objp
== objfile
)
342 /* Unhook it from where it is. */
343 *objp
= objfile
->next
;
344 /* Put it in the front. */
345 objfile
->next
= object_files
;
346 object_files
= objfile
;
352 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
355 It is not a bug, or error, to call this function if OBJFILE is not known
356 to be in the current list. This is done in the case of mapped objfiles,
357 for example, just to ensure that the mapped objfile doesn't appear twice
358 in the list. Since the list is threaded, linking in a mapped objfile
359 twice would create a circular list.
361 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
362 unlinking it, just to ensure that we have completely severed any linkages
363 between the OBJFILE and the list. */
366 unlink_objfile (objfile
)
367 struct objfile
*objfile
;
369 struct objfile
**objpp
;
371 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
373 if (*objpp
== objfile
)
375 *objpp
= (*objpp
)->next
;
376 objfile
->next
= NULL
;
381 internal_error ("objfiles.c (unlink_objfile): objfile already unlinked");
385 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
386 that as much as possible is allocated on the symbol_obstack and
387 psymbol_obstack, so that the memory can be efficiently freed.
389 Things which we do NOT free because they are not in malloc'd memory
390 or not in memory specific to the objfile include:
394 FIXME: If the objfile is using reusable symbol information (via mmalloc),
395 then we need to take into account the fact that more than one process
396 may be using the symbol information at the same time (when mmalloc is
397 extended to support cooperative locking). When more than one process
398 is using the mapped symbol info, we need to be more careful about when
399 we free objects in the reusable area. */
402 free_objfile (objfile
)
403 struct objfile
*objfile
;
405 /* First do any symbol file specific actions required when we are
406 finished with a particular symbol file. Note that if the objfile
407 is using reusable symbol information (via mmalloc) then each of
408 these routines is responsible for doing the correct thing, either
409 freeing things which are valid only during this particular gdb
410 execution, or leaving them to be reused during the next one. */
412 if (objfile
->sf
!= NULL
)
414 (*objfile
->sf
->sym_finish
) (objfile
);
417 /* We always close the bfd. */
419 if (objfile
->obfd
!= NULL
)
421 char *name
= bfd_get_filename (objfile
->obfd
);
422 if (!bfd_close (objfile
->obfd
))
423 warning ("cannot close \"%s\": %s",
424 name
, bfd_errmsg (bfd_get_error ()));
428 /* Remove it from the chain of all objfiles. */
430 unlink_objfile (objfile
);
432 /* If we are going to free the runtime common objfile, mark it
435 if (objfile
== rt_common_objfile
)
436 rt_common_objfile
= NULL
;
438 /* Before the symbol table code was redone to make it easier to
439 selectively load and remove information particular to a specific
440 linkage unit, gdb used to do these things whenever the monolithic
441 symbol table was blown away. How much still needs to be done
442 is unknown, but we play it safe for now and keep each action until
443 it is shown to be no longer needed. */
445 /* I *think* all our callers call clear_symtab_users. If so, no need
446 to call this here. */
447 clear_pc_function_cache ();
449 /* The last thing we do is free the objfile struct itself for the
450 non-reusable case, or detach from the mapped file for the reusable
451 case. Note that the mmalloc_detach or the mfree is the last thing
452 we can do with this objfile. */
454 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
456 if (objfile
->flags
& OBJF_MAPPED
)
458 /* Remember the fd so we can close it. We can't close it before
459 doing the detach, and after the detach the objfile is gone. */
462 mmfd
= objfile
->mmfd
;
463 mmalloc_detach (objfile
->md
);
468 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
470 /* If we still have an objfile, then either we don't support reusable
471 objfiles or this one was not reusable. So free it normally. */
475 if (objfile
->name
!= NULL
)
477 mfree (objfile
->md
, objfile
->name
);
479 if (objfile
->global_psymbols
.list
)
480 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
481 if (objfile
->static_psymbols
.list
)
482 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
483 /* Free the obstacks for non-reusable objfiles */
484 free_bcache (&objfile
->psymbol_cache
);
485 obstack_free (&objfile
->psymbol_obstack
, 0);
486 obstack_free (&objfile
->symbol_obstack
, 0);
487 obstack_free (&objfile
->type_obstack
, 0);
488 mfree (objfile
->md
, objfile
);
494 do_free_objfile_cleanup (void *obj
)
500 make_cleanup_free_objfile (struct objfile
*obj
)
502 return make_cleanup (do_free_objfile_cleanup
, obj
);
505 /* Free all the object files at once and clean up their users. */
510 struct objfile
*objfile
, *temp
;
512 ALL_OBJFILES_SAFE (objfile
, temp
)
514 free_objfile (objfile
);
516 clear_symtab_users ();
519 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
520 entries in new_offsets. */
522 objfile_relocate (objfile
, new_offsets
)
523 struct objfile
*objfile
;
524 struct section_offsets
*new_offsets
;
526 struct section_offsets
*delta
=
527 (struct section_offsets
*) alloca (SIZEOF_SECTION_OFFSETS
);
531 int something_changed
= 0;
532 for (i
= 0; i
< objfile
->num_sections
; ++i
)
534 ANOFFSET (delta
, i
) =
535 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
536 if (ANOFFSET (delta
, i
) != 0)
537 something_changed
= 1;
539 if (!something_changed
)
543 /* OK, get all the symtabs. */
547 ALL_OBJFILE_SYMTABS (objfile
, s
)
550 struct blockvector
*bv
;
553 /* First the line table. */
557 for (i
= 0; i
< l
->nitems
; ++i
)
558 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
561 /* Don't relocate a shared blockvector more than once. */
565 bv
= BLOCKVECTOR (s
);
566 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
571 b
= BLOCKVECTOR_BLOCK (bv
, i
);
572 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
573 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
575 for (j
= 0; j
< BLOCK_NSYMS (b
); ++j
)
577 struct symbol
*sym
= BLOCK_SYM (b
, j
);
578 /* The RS6000 code from which this was taken skipped
579 any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
580 But I'm leaving out that test, on the theory that
581 they can't possibly pass the tests below. */
582 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
583 || SYMBOL_CLASS (sym
) == LOC_STATIC
584 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
585 && SYMBOL_SECTION (sym
) >= 0)
587 SYMBOL_VALUE_ADDRESS (sym
) +=
588 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
590 #ifdef MIPS_EFI_SYMBOL_NAME
591 /* Relocate Extra Function Info for ecoff. */
593 else if (SYMBOL_CLASS (sym
) == LOC_CONST
594 && SYMBOL_NAMESPACE (sym
) == LABEL_NAMESPACE
595 && STRCMP (SYMBOL_NAME (sym
), MIPS_EFI_SYMBOL_NAME
) == 0)
596 ecoff_relocate_efi (sym
, ANOFFSET (delta
,
597 s
->block_line_section
));
605 struct partial_symtab
*p
;
607 ALL_OBJFILE_PSYMTABS (objfile
, p
)
609 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
610 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
615 struct partial_symbol
**psym
;
617 for (psym
= objfile
->global_psymbols
.list
;
618 psym
< objfile
->global_psymbols
.next
;
620 if (SYMBOL_SECTION (*psym
) >= 0)
621 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
622 SYMBOL_SECTION (*psym
));
623 for (psym
= objfile
->static_psymbols
.list
;
624 psym
< objfile
->static_psymbols
.next
;
626 if (SYMBOL_SECTION (*psym
) >= 0)
627 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
628 SYMBOL_SECTION (*psym
));
632 struct minimal_symbol
*msym
;
633 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
634 if (SYMBOL_SECTION (msym
) >= 0)
635 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
637 /* Relocating different sections by different amounts may cause the symbols
638 to be out of order. */
639 msymbols_sort (objfile
);
643 for (i
= 0; i
< objfile
->num_sections
; ++i
)
644 ANOFFSET (objfile
->section_offsets
, i
) = ANOFFSET (new_offsets
, i
);
648 struct obj_section
*s
;
651 abfd
= objfile
->obfd
;
653 ALL_OBJFILE_OSECTIONS (objfile
, s
)
657 flags
= bfd_get_section_flags (abfd
, s
->the_bfd_section
);
659 if (flags
& SEC_CODE
)
661 s
->addr
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
662 s
->endaddr
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
664 else if (flags
& (SEC_DATA
| SEC_LOAD
))
666 s
->addr
+= ANOFFSET (delta
, SECT_OFF_DATA (objfile
));
667 s
->endaddr
+= ANOFFSET (delta
, SECT_OFF_DATA (objfile
));
669 else if (flags
& SEC_ALLOC
)
671 s
->addr
+= ANOFFSET (delta
, SECT_OFF_BSS (objfile
));
672 s
->endaddr
+= ANOFFSET (delta
, SECT_OFF_BSS (objfile
));
677 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
678 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
680 if (objfile
->ei
.entry_func_lowpc
!= INVALID_ENTRY_LOWPC
)
682 objfile
->ei
.entry_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
683 objfile
->ei
.entry_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
686 if (objfile
->ei
.entry_file_lowpc
!= INVALID_ENTRY_LOWPC
)
688 objfile
->ei
.entry_file_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
689 objfile
->ei
.entry_file_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
692 if (objfile
->ei
.main_func_lowpc
!= INVALID_ENTRY_LOWPC
)
694 objfile
->ei
.main_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
695 objfile
->ei
.main_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
698 /* Relocate breakpoints as necessary, after things are relocated. */
699 breakpoint_re_set ();
702 /* Many places in gdb want to test just to see if we have any partial
703 symbols available. This function returns zero if none are currently
704 available, nonzero otherwise. */
707 have_partial_symbols ()
713 if (ofp
->psymtabs
!= NULL
)
721 /* Many places in gdb want to test just to see if we have any full
722 symbols available. This function returns zero if none are currently
723 available, nonzero otherwise. */
732 if (ofp
->symtabs
!= NULL
)
741 /* This operations deletes all objfile entries that represent solibs that
742 weren't explicitly loaded by the user, via e.g., the add-symbol-file
746 objfile_purge_solibs ()
748 struct objfile
*objf
;
749 struct objfile
*temp
;
751 ALL_OBJFILES_SAFE (objf
, temp
)
753 /* We assume that the solib package has been purged already, or will
756 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
762 /* Many places in gdb want to test just to see if we have any minimal
763 symbols available. This function returns zero if none are currently
764 available, nonzero otherwise. */
767 have_minimal_symbols ()
773 if (ofp
->msymbols
!= NULL
)
781 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
783 /* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
784 of the corresponding symbol file in MTIME, try to open an existing file
785 with the name SYMSFILENAME and verify it is more recent than the base
786 file by checking it's timestamp against MTIME.
788 If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
790 If SYMSFILENAME does exist, but is out of date, we check to see if the
791 user has specified creation of a mapped file. If so, we don't issue
792 any warning message because we will be creating a new mapped file anyway,
793 overwriting the old one. If not, then we issue a warning message so that
794 the user will know why we aren't using this existing mapped symbol file.
795 In either case, we return -1.
797 If SYMSFILENAME does exist and is not out of date, but can't be opened for
798 some reason, then prints an appropriate system error message and returns -1.
800 Otherwise, returns the open file descriptor. */
803 open_existing_mapped_file (symsfilename
, mtime
, flags
)
811 if (stat (symsfilename
, &sbuf
) == 0)
813 if (sbuf
.st_mtime
< mtime
)
815 if (!(flags
& OBJF_MAPPED
))
817 warning ("mapped symbol file `%s' is out of date, ignored it",
821 else if ((fd
= open (symsfilename
, O_RDWR
)) < 0)
825 printf_unfiltered (error_pre_print
);
827 print_sys_errmsg (symsfilename
, errno
);
833 /* Look for a mapped symbol file that corresponds to FILENAME and is more
834 recent than MTIME. If MAPPED is nonzero, the user has asked that gdb
835 use a mapped symbol file for this file, so create a new one if one does
838 If found, then return an open file descriptor for the file, otherwise
841 This routine is responsible for implementing the policy that generates
842 the name of the mapped symbol file from the name of a file containing
843 symbols that gdb would like to read. Currently this policy is to append
844 ".syms" to the name of the file.
846 This routine is also responsible for implementing the policy that
847 determines where the mapped symbol file is found (the search path).
848 This policy is that when reading an existing mapped file, a file of
849 the correct name in the current directory takes precedence over a
850 file of the correct name in the same directory as the symbol file.
851 When creating a new mapped file, it is always created in the current
852 directory. This helps to minimize the chances of a user unknowingly
853 creating big mapped files in places like /bin and /usr/local/bin, and
854 allows a local copy to override a manually installed global copy (in
855 /bin for example). */
858 open_mapped_file (filename
, mtime
, flags
)
866 /* First try to open an existing file in the current directory, and
867 then try the directory where the symbol file is located. */
869 symsfilename
= concat ("./", basename (filename
), ".syms", (char *) NULL
);
870 if ((fd
= open_existing_mapped_file (symsfilename
, mtime
, flags
)) < 0)
873 symsfilename
= concat (filename
, ".syms", (char *) NULL
);
874 fd
= open_existing_mapped_file (symsfilename
, mtime
, flags
);
877 /* If we don't have an open file by now, then either the file does not
878 already exist, or the base file has changed since it was created. In
879 either case, if the user has specified use of a mapped file, then
880 create a new mapped file, truncating any existing one. If we can't
881 create one, print a system error message saying why we can't.
883 By default the file is rw for everyone, with the user's umask taking
884 care of turning off the permissions the user wants off. */
886 if ((fd
< 0) && (flags
& OBJF_MAPPED
))
889 symsfilename
= concat ("./", basename (filename
), ".syms",
891 if ((fd
= open (symsfilename
, O_RDWR
| O_CREAT
| O_TRUNC
, 0666)) < 0)
895 printf_unfiltered (error_pre_print
);
897 print_sys_errmsg (symsfilename
, errno
);
912 md
= mmalloc_attach (fd
, (PTR
) 0);
915 mapto
= (CORE_ADDR
) mmalloc_getkey (md
, 1);
916 md
= mmalloc_detach (md
);
919 /* FIXME: should figure out why detach failed */
922 else if (mapto
!= (CORE_ADDR
) NULL
)
924 /* This mapping file needs to be remapped at "mapto" */
925 md
= mmalloc_attach (fd
, (PTR
) mapto
);
929 /* This is a freshly created mapping file. */
930 mapto
= (CORE_ADDR
) mmalloc_findbase (20 * 1024 * 1024);
933 /* To avoid reusing the freshly created mapping file, at the
934 address selected by mmap, we must truncate it before trying
935 to do an attach at the address we want. */
937 md
= mmalloc_attach (fd
, (PTR
) mapto
);
940 mmalloc_setkey (md
, 1, (PTR
) mapto
);
948 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
950 /* Returns a section whose range includes PC and SECTION,
951 or NULL if none found. Note the distinction between the return type,
952 struct obj_section (which is defined in gdb), and the input type
953 struct sec (which is a bfd-defined data type). The obj_section
954 contains a pointer to the bfd struct sec section. */
957 find_pc_sect_section (pc
, section
)
961 struct obj_section
*s
;
962 struct objfile
*objfile
;
964 ALL_OBJSECTIONS (objfile
, s
)
965 if ((section
== 0 || section
== s
->the_bfd_section
) &&
966 s
->addr
<= pc
&& pc
< s
->endaddr
)
972 /* Returns a section whose range includes PC or NULL if none found.
973 Backward compatibility, no section. */
979 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
983 /* In SVR4, we recognize a trampoline by it's section name.
984 That is, if the pc is in a section named ".plt" then we are in
988 in_plt_section (pc
, name
)
992 struct obj_section
*s
;
995 s
= find_pc_section (pc
);
998 && s
->the_bfd_section
->name
!= NULL
999 && STREQ (s
->the_bfd_section
->name
, ".plt"));
1003 /* Return nonzero if NAME is in the import list of OBJFILE. Else
1007 is_in_import_list (name
, objfile
)
1009 struct objfile
*objfile
;
1013 if (!objfile
|| !name
|| !*name
)
1016 for (i
= 0; i
< objfile
->import_list_size
; i
++)
1017 if (objfile
->import_list
[i
] && STREQ (name
, objfile
->import_list
[i
]))
This page took 0.055689 seconds and 4 git commands to generate.