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, Boston, MA 02111-1307, USA. */
21 /* This file contains support routines for creating, manipulating, and
22 destroying objfile structures. */
25 #include "bfd.h" /* Binary File Description */
29 #include "gdb-stabs.h"
32 #include <sys/types.h>
36 #include "gdb_string.h"
38 /* Prototypes for local functions */
40 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
43 open_existing_mapped_file
PARAMS ((char *, long, int));
46 open_mapped_file
PARAMS ((char *filename
, long mtime
, int mapped
));
49 map_to_file
PARAMS ((int));
51 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
54 add_to_objfile_sections
PARAMS ((bfd
*, sec_ptr
, PTR
));
56 /* Externally visible variables that are owned by this module.
57 See declarations in objfile.h for more info. */
59 struct objfile
*object_files
; /* Linked list of all objfiles */
60 struct objfile
*current_objfile
; /* For symbol file being read in */
61 struct objfile
*symfile_objfile
; /* Main symbol table loaded from */
62 struct objfile
*rt_common_objfile
; /* For runtime common symbols */
64 int mapped_symbol_files
; /* Try to use mapped symbol files */
66 /* Locate all mappable sections of a BFD file.
67 objfile_p_char is a char * to get it through
68 bfd_map_over_sections; we cast it back to its proper type. */
70 #ifndef TARGET_KEEP_SECTION
71 #define TARGET_KEEP_SECTION(ASECT) 0
75 add_to_objfile_sections (abfd
, asect
, objfile_p_char
)
80 struct objfile
*objfile
= (struct objfile
*) objfile_p_char
;
81 struct obj_section section
;
84 aflag
= bfd_get_section_flags (abfd
, asect
);
86 if (!(aflag
& SEC_ALLOC
) && !(TARGET_KEEP_SECTION(asect
)))
89 if (0 == bfd_section_size (abfd
, asect
))
92 section
.objfile
= objfile
;
93 section
.the_bfd_section
= asect
;
94 section
.ovly_mapped
= 0;
95 section
.addr
= bfd_section_vma (abfd
, asect
);
96 section
.endaddr
= section
.addr
+ bfd_section_size (abfd
, asect
);
97 obstack_grow (&objfile
->psymbol_obstack
, (char *) §ion
, sizeof(section
));
98 objfile
->sections_end
= (struct obj_section
*) (((unsigned long) objfile
->sections_end
) + 1);
101 /* Builds a section table for OBJFILE.
102 Returns 0 if OK, 1 on error (in which case bfd_error contains the
106 build_objfile_section_table (objfile
)
107 struct objfile
*objfile
;
109 /* objfile->sections can be already set when reading a mapped symbol
110 file. I believe that we do need to rebuild the section table in
111 this case (we rebuild other things derived from the bfd), but we
112 can't free the old one (it's in the psymbol_obstack). So we just
113 waste some memory. */
115 objfile
->sections_end
= 0;
116 bfd_map_over_sections (objfile
->obfd
, add_to_objfile_sections
, (char *)objfile
);
117 objfile
->sections
= (struct obj_section
*)
118 obstack_finish (&objfile
->psymbol_obstack
);
119 objfile
->sections_end
= objfile
->sections
+ (unsigned long) objfile
->sections_end
;
123 /* Given a pointer to an initialized bfd (ABFD) and a flag that indicates
124 whether or not an objfile is to be mapped (MAPPED), allocate a new objfile
125 struct, fill it in as best we can, link it into the list of all known
126 objfiles, and return a pointer to the new objfile struct.
128 USER_LOADED is simply recorded in the objfile. This record offers a way for
129 run_command to remove old objfile entries which are no longer valid (i.e.,
130 are associated with an old inferior), but to preserve ones that the user
131 explicitly loaded via the add-symbol-file command.
133 IS_SOLIB is also simply recorded in the objfile. */
136 allocate_objfile (abfd
, mapped
, user_loaded
, is_solib
)
142 struct objfile
*objfile
= NULL
;
143 struct objfile
*last_one
= NULL
;
145 mapped
|= mapped_symbol_files
;
147 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
151 /* If we can support mapped symbol files, try to open/reopen the
152 mapped file that corresponds to the file from which we wish to
153 read symbols. If the objfile is to be mapped, we must malloc
154 the structure itself using the mmap version, and arrange that
155 all memory allocation for the objfile uses the mmap routines.
156 If we are reusing an existing mapped file, from which we get
157 our objfile pointer, we have to make sure that we update the
158 pointers to the alloc/free functions in the obstack, in case
159 these functions have moved within the current gdb. */
163 fd
= open_mapped_file (bfd_get_filename (abfd
), bfd_get_mtime (abfd
),
169 if ((md
= map_to_file (fd
)) == NULL
)
173 else if ((objfile
= (struct objfile
*) mmalloc_getkey (md
, 0)) != NULL
)
175 /* Update memory corruption handler function addresses. */
178 objfile
-> mmfd
= fd
;
179 /* Update pointers to functions to *our* copies */
180 obstack_chunkfun (&objfile
-> psymbol_cache
.cache
, xmmalloc
);
181 obstack_freefun (&objfile
-> psymbol_cache
.cache
, mfree
);
182 obstack_chunkfun (&objfile
-> psymbol_obstack
, xmmalloc
);
183 obstack_freefun (&objfile
-> psymbol_obstack
, mfree
);
184 obstack_chunkfun (&objfile
-> symbol_obstack
, xmmalloc
);
185 obstack_freefun (&objfile
-> symbol_obstack
, mfree
);
186 obstack_chunkfun (&objfile
-> type_obstack
, xmmalloc
);
187 obstack_freefun (&objfile
-> type_obstack
, mfree
);
188 /* If already in objfile list, unlink it. */
189 unlink_objfile (objfile
);
190 /* Forget things specific to a particular gdb, may have changed. */
191 objfile
-> sf
= NULL
;
196 /* Set up to detect internal memory corruption. MUST be
197 done before the first malloc. See comments in
198 init_malloc() and mmcheck(). */
202 objfile
= (struct objfile
*)
203 xmmalloc (md
, sizeof (struct objfile
));
204 memset (objfile
, 0, sizeof (struct objfile
));
206 objfile
-> mmfd
= fd
;
207 objfile
-> flags
|= OBJF_MAPPED
;
208 mmalloc_setkey (objfile
-> md
, 0, objfile
);
209 obstack_specify_allocation_with_arg (&objfile
-> psymbol_cache
.cache
,
210 0, 0, xmmalloc
, mfree
,
212 obstack_specify_allocation_with_arg (&objfile
-> psymbol_obstack
,
213 0, 0, xmmalloc
, mfree
,
215 obstack_specify_allocation_with_arg (&objfile
-> symbol_obstack
,
216 0, 0, xmmalloc
, mfree
,
218 obstack_specify_allocation_with_arg (&objfile
-> type_obstack
,
219 0, 0, xmmalloc
, mfree
,
224 if (mapped
&& (objfile
== NULL
))
226 warning ("symbol table for '%s' will not be mapped",
227 bfd_get_filename (abfd
));
230 #else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
234 warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
236 /* Turn off the global flag so we don't try to do mapped symbol tables
237 any more, which shuts up gdb unless the user specifically gives the
238 "mapped" keyword again. */
240 mapped_symbol_files
= 0;
243 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
245 /* If we don't support mapped symbol files, didn't ask for the file to be
246 mapped, or failed to open the mapped file for some reason, then revert
247 back to an unmapped objfile. */
251 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
252 memset (objfile
, 0, sizeof (struct objfile
));
253 objfile
-> md
= NULL
;
254 obstack_specify_allocation (&objfile
-> psymbol_cache
.cache
, 0, 0,
256 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0, xmalloc
,
258 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0, xmalloc
,
260 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0, xmalloc
,
264 /* Update the per-objfile information that comes from the bfd, ensuring
265 that any data that is reference is saved in the per-objfile data
268 objfile
-> obfd
= abfd
;
269 if (objfile
-> name
!= NULL
)
271 mfree (objfile
-> md
, objfile
-> name
);
275 objfile
-> name
= mstrsave (objfile
-> md
, bfd_get_filename (abfd
));
276 objfile
-> mtime
= bfd_get_mtime (abfd
);
278 /* Build section table. */
280 if (build_objfile_section_table (objfile
))
282 error ("Can't find the file sections in `%s': %s",
283 objfile
-> name
, bfd_errmsg (bfd_get_error ()));
287 /* Add this file onto the tail of the linked list of other such files. */
289 objfile
-> next
= NULL
;
290 if (object_files
== NULL
)
291 object_files
= objfile
;
294 for (last_one
= object_files
;
296 last_one
= last_one
-> next
);
297 last_one
-> next
= objfile
;
300 /* Record whether this objfile was created because the user explicitly
301 caused it (e.g., used the add-symbol-file command).
303 objfile
-> user_loaded
= user_loaded
;
305 /* Record whether this objfile definitely represents a solib. */
306 objfile
-> is_solib
= is_solib
;
311 /* Put OBJFILE at the front of the list. */
314 objfile_to_front (objfile
)
315 struct objfile
*objfile
;
317 struct objfile
**objp
;
318 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
320 if (*objp
== objfile
)
322 /* Unhook it from where it is. */
323 *objp
= objfile
->next
;
324 /* Put it in the front. */
325 objfile
->next
= object_files
;
326 object_files
= objfile
;
332 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
335 It is not a bug, or error, to call this function if OBJFILE is not known
336 to be in the current list. This is done in the case of mapped objfiles,
337 for example, just to ensure that the mapped objfile doesn't appear twice
338 in the list. Since the list is threaded, linking in a mapped objfile
339 twice would create a circular list.
341 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
342 unlinking it, just to ensure that we have completely severed any linkages
343 between the OBJFILE and the list. */
346 unlink_objfile (objfile
)
347 struct objfile
*objfile
;
349 struct objfile
** objpp
;
351 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
) -> next
))
353 if (*objpp
== objfile
)
355 *objpp
= (*objpp
) -> next
;
356 objfile
-> next
= NULL
;
363 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
364 that as much as possible is allocated on the symbol_obstack and
365 psymbol_obstack, so that the memory can be efficiently freed.
367 Things which we do NOT free because they are not in malloc'd memory
368 or not in memory specific to the objfile include:
372 FIXME: If the objfile is using reusable symbol information (via mmalloc),
373 then we need to take into account the fact that more than one process
374 may be using the symbol information at the same time (when mmalloc is
375 extended to support cooperative locking). When more than one process
376 is using the mapped symbol info, we need to be more careful about when
377 we free objects in the reusable area. */
380 free_objfile (objfile
)
381 struct objfile
*objfile
;
383 /* First do any symbol file specific actions required when we are
384 finished with a particular symbol file. Note that if the objfile
385 is using reusable symbol information (via mmalloc) then each of
386 these routines is responsible for doing the correct thing, either
387 freeing things which are valid only during this particular gdb
388 execution, or leaving them to be reused during the next one. */
390 if (objfile
-> sf
!= NULL
)
392 (*objfile
-> sf
-> sym_finish
) (objfile
);
395 /* We always close the bfd. */
397 if (objfile
-> obfd
!= NULL
)
399 char *name
= bfd_get_filename (objfile
->obfd
);
400 if (!bfd_close (objfile
-> obfd
))
401 warning ("cannot close \"%s\": %s",
402 name
, bfd_errmsg (bfd_get_error ()));
406 /* Remove it from the chain of all objfiles. */
408 unlink_objfile (objfile
);
410 /* If we are going to free the runtime common objfile, mark it
413 if (objfile
== rt_common_objfile
)
414 rt_common_objfile
= NULL
;
416 /* Before the symbol table code was redone to make it easier to
417 selectively load and remove information particular to a specific
418 linkage unit, gdb used to do these things whenever the monolithic
419 symbol table was blown away. How much still needs to be done
420 is unknown, but we play it safe for now and keep each action until
421 it is shown to be no longer needed. */
423 #if defined (CLEAR_SOLIB)
425 /* CLEAR_SOLIB closes the bfd's for any shared libraries. But
426 the to_sections for a core file might refer to those bfd's. So
427 detach any core file. */
429 struct target_ops
*t
= find_core_target ();
431 (t
->to_detach
) (NULL
, 0);
434 /* I *think* all our callers call clear_symtab_users. If so, no need
435 to call this here. */
436 clear_pc_function_cache ();
438 /* The last thing we do is free the objfile struct itself for the
439 non-reusable case, or detach from the mapped file for the reusable
440 case. Note that the mmalloc_detach or the mfree is the last thing
441 we can do with this objfile. */
443 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
445 if (objfile
-> flags
& OBJF_MAPPED
)
447 /* Remember the fd so we can close it. We can't close it before
448 doing the detach, and after the detach the objfile is gone. */
451 mmfd
= objfile
-> mmfd
;
452 mmalloc_detach (objfile
-> md
);
457 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
459 /* If we still have an objfile, then either we don't support reusable
460 objfiles or this one was not reusable. So free it normally. */
464 if (objfile
-> name
!= NULL
)
466 mfree (objfile
-> md
, objfile
-> name
);
468 if (objfile
->global_psymbols
.list
)
469 mfree (objfile
->md
, objfile
->global_psymbols
.list
);
470 if (objfile
->static_psymbols
.list
)
471 mfree (objfile
->md
, objfile
->static_psymbols
.list
);
472 /* Free the obstacks for non-reusable objfiles */
473 obstack_free (&objfile
-> psymbol_cache
.cache
, 0);
474 obstack_free (&objfile
-> psymbol_obstack
, 0);
475 obstack_free (&objfile
-> symbol_obstack
, 0);
476 obstack_free (&objfile
-> type_obstack
, 0);
477 mfree (objfile
-> md
, objfile
);
483 /* Free all the object files at once and clean up their users. */
488 struct objfile
*objfile
, *temp
;
490 ALL_OBJFILES_SAFE (objfile
, temp
)
492 free_objfile (objfile
);
494 clear_symtab_users ();
497 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
498 entries in new_offsets. */
500 objfile_relocate (objfile
, new_offsets
)
501 struct objfile
*objfile
;
502 struct section_offsets
*new_offsets
;
504 struct section_offsets
*delta
= (struct section_offsets
*)
505 alloca (sizeof (struct section_offsets
)
506 + objfile
->num_sections
* sizeof (delta
->offsets
));
510 int something_changed
= 0;
511 for (i
= 0; i
< objfile
->num_sections
; ++i
)
513 ANOFFSET (delta
, i
) =
514 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
515 if (ANOFFSET (delta
, i
) != 0)
516 something_changed
= 1;
518 if (!something_changed
)
522 /* OK, get all the symtabs. */
526 ALL_OBJFILE_SYMTABS (objfile
, s
)
529 struct blockvector
*bv
;
532 /* First the line table. */
536 for (i
= 0; i
< l
->nitems
; ++i
)
537 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
540 /* Don't relocate a shared blockvector more than once. */
544 bv
= BLOCKVECTOR (s
);
545 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
550 b
= BLOCKVECTOR_BLOCK (bv
, i
);
551 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
552 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
554 for (j
= 0; j
< BLOCK_NSYMS (b
); ++j
)
556 struct symbol
*sym
= BLOCK_SYM (b
, j
);
557 /* The RS6000 code from which this was taken skipped
558 any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
559 But I'm leaving out that test, on the theory that
560 they can't possibly pass the tests below. */
561 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
562 || SYMBOL_CLASS (sym
) == LOC_STATIC
563 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
564 && SYMBOL_SECTION (sym
) >= 0)
566 SYMBOL_VALUE_ADDRESS (sym
) +=
567 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
569 #ifdef MIPS_EFI_SYMBOL_NAME
570 /* Relocate Extra Function Info for ecoff. */
573 if (SYMBOL_CLASS (sym
) == LOC_CONST
574 && SYMBOL_NAMESPACE (sym
) == LABEL_NAMESPACE
575 && STRCMP (SYMBOL_NAME (sym
), MIPS_EFI_SYMBOL_NAME
) == 0)
576 ecoff_relocate_efi (sym
, ANOFFSET (delta
,
577 s
->block_line_section
));
585 struct partial_symtab
*p
;
587 ALL_OBJFILE_PSYMTABS (objfile
, p
)
589 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
590 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
595 struct partial_symbol
**psym
;
597 for (psym
= objfile
->global_psymbols
.list
;
598 psym
< objfile
->global_psymbols
.next
;
600 if (SYMBOL_SECTION (*psym
) >= 0)
601 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
602 SYMBOL_SECTION (*psym
));
603 for (psym
= objfile
->static_psymbols
.list
;
604 psym
< objfile
->static_psymbols
.next
;
606 if (SYMBOL_SECTION (*psym
) >= 0)
607 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
608 SYMBOL_SECTION (*psym
));
612 struct minimal_symbol
*msym
;
613 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
614 if (SYMBOL_SECTION (msym
) >= 0)
615 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
617 /* Relocating different sections by different amounts may cause the symbols
618 to be out of order. */
619 msymbols_sort (objfile
);
623 for (i
= 0; i
< objfile
->num_sections
; ++i
)
624 ANOFFSET (objfile
->section_offsets
, i
) = ANOFFSET (new_offsets
, i
);
628 struct obj_section
*s
;
631 abfd
= objfile
->obfd
;
633 for (s
= objfile
->sections
;
634 s
< objfile
->sections_end
; ++s
)
638 flags
= bfd_get_section_flags (abfd
, s
->the_bfd_section
);
640 if (flags
& SEC_CODE
)
642 s
->addr
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
643 s
->endaddr
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
645 else if (flags
& (SEC_DATA
| SEC_LOAD
))
647 s
->addr
+= ANOFFSET (delta
, SECT_OFF_DATA
);
648 s
->endaddr
+= ANOFFSET (delta
, SECT_OFF_DATA
);
650 else if (flags
& SEC_ALLOC
)
652 s
->addr
+= ANOFFSET (delta
, SECT_OFF_BSS
);
653 s
->endaddr
+= ANOFFSET (delta
, SECT_OFF_BSS
);
658 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
)0)
659 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
661 if (objfile
->ei
.entry_func_lowpc
!= INVALID_ENTRY_LOWPC
)
663 objfile
->ei
.entry_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
664 objfile
->ei
.entry_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
667 if (objfile
->ei
.entry_file_lowpc
!= INVALID_ENTRY_LOWPC
)
669 objfile
->ei
.entry_file_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
670 objfile
->ei
.entry_file_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
673 if (objfile
->ei
.main_func_lowpc
!= INVALID_ENTRY_LOWPC
)
675 objfile
->ei
.main_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
676 objfile
->ei
.main_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT
);
679 /* Relocate breakpoints as necessary, after things are relocated. */
680 breakpoint_re_set ();
683 /* Many places in gdb want to test just to see if we have any partial
684 symbols available. This function returns zero if none are currently
685 available, nonzero otherwise. */
688 have_partial_symbols ()
694 if (ofp
-> psymtabs
!= NULL
)
702 /* Many places in gdb want to test just to see if we have any full
703 symbols available. This function returns zero if none are currently
704 available, nonzero otherwise. */
713 if (ofp
-> symtabs
!= NULL
)
722 /* This operations deletes all objfile entries that represent solibs that
723 weren't explicitly loaded by the user, via e.g., the add-symbol-file
727 objfile_purge_solibs ()
729 struct objfile
* objf
;
730 struct objfile
* temp
;
732 ALL_OBJFILES_SAFE (objf
, temp
)
734 /* We assume that the solib package has been purged already, or will
737 if (! objf
->user_loaded
&& objf
->is_solib
)
743 /* Many places in gdb want to test just to see if we have any minimal
744 symbols available. This function returns zero if none are currently
745 available, nonzero otherwise. */
748 have_minimal_symbols ()
754 if (ofp
-> msymbols
!= NULL
)
762 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
764 /* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
765 of the corresponding symbol file in MTIME, try to open an existing file
766 with the name SYMSFILENAME and verify it is more recent than the base
767 file by checking it's timestamp against MTIME.
769 If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
771 If SYMSFILENAME does exist, but is out of date, we check to see if the
772 user has specified creation of a mapped file. If so, we don't issue
773 any warning message because we will be creating a new mapped file anyway,
774 overwriting the old one. If not, then we issue a warning message so that
775 the user will know why we aren't using this existing mapped symbol file.
776 In either case, we return -1.
778 If SYMSFILENAME does exist and is not out of date, but can't be opened for
779 some reason, then prints an appropriate system error message and returns -1.
781 Otherwise, returns the open file descriptor. */
784 open_existing_mapped_file (symsfilename
, mtime
, mapped
)
792 if (stat (symsfilename
, &sbuf
) == 0)
794 if (sbuf
.st_mtime
< mtime
)
798 warning ("mapped symbol file `%s' is out of date, ignored it",
802 else if ((fd
= open (symsfilename
, O_RDWR
)) < 0)
806 printf_unfiltered (error_pre_print
);
808 print_sys_errmsg (symsfilename
, errno
);
814 /* Look for a mapped symbol file that corresponds to FILENAME and is more
815 recent than MTIME. If MAPPED is nonzero, the user has asked that gdb
816 use a mapped symbol file for this file, so create a new one if one does
819 If found, then return an open file descriptor for the file, otherwise
822 This routine is responsible for implementing the policy that generates
823 the name of the mapped symbol file from the name of a file containing
824 symbols that gdb would like to read. Currently this policy is to append
825 ".syms" to the name of the file.
827 This routine is also responsible for implementing the policy that
828 determines where the mapped symbol file is found (the search path).
829 This policy is that when reading an existing mapped file, a file of
830 the correct name in the current directory takes precedence over a
831 file of the correct name in the same directory as the symbol file.
832 When creating a new mapped file, it is always created in the current
833 directory. This helps to minimize the chances of a user unknowingly
834 creating big mapped files in places like /bin and /usr/local/bin, and
835 allows a local copy to override a manually installed global copy (in
836 /bin for example). */
839 open_mapped_file (filename
, mtime
, mapped
)
847 /* First try to open an existing file in the current directory, and
848 then try the directory where the symbol file is located. */
850 symsfilename
= concat ("./", basename (filename
), ".syms", (char *) NULL
);
851 if ((fd
= open_existing_mapped_file (symsfilename
, mtime
, mapped
)) < 0)
854 symsfilename
= concat (filename
, ".syms", (char *) NULL
);
855 fd
= open_existing_mapped_file (symsfilename
, mtime
, mapped
);
858 /* If we don't have an open file by now, then either the file does not
859 already exist, or the base file has changed since it was created. In
860 either case, if the user has specified use of a mapped file, then
861 create a new mapped file, truncating any existing one. If we can't
862 create one, print a system error message saying why we can't.
864 By default the file is rw for everyone, with the user's umask taking
865 care of turning off the permissions the user wants off. */
867 if ((fd
< 0) && mapped
)
870 symsfilename
= concat ("./", basename (filename
), ".syms",
872 if ((fd
= open (symsfilename
, O_RDWR
| O_CREAT
| O_TRUNC
, 0666)) < 0)
876 printf_unfiltered (error_pre_print
);
878 print_sys_errmsg (symsfilename
, errno
);
893 md
= mmalloc_attach (fd
, (PTR
) 0);
896 mapto
= (CORE_ADDR
) mmalloc_getkey (md
, 1);
897 md
= mmalloc_detach (md
);
900 /* FIXME: should figure out why detach failed */
903 else if (mapto
!= (CORE_ADDR
) NULL
)
905 /* This mapping file needs to be remapped at "mapto" */
906 md
= mmalloc_attach (fd
, (PTR
) mapto
);
910 /* This is a freshly created mapping file. */
911 mapto
= (CORE_ADDR
) mmalloc_findbase (20 * 1024 * 1024);
914 /* To avoid reusing the freshly created mapping file, at the
915 address selected by mmap, we must truncate it before trying
916 to do an attach at the address we want. */
918 md
= mmalloc_attach (fd
, (PTR
) mapto
);
921 mmalloc_setkey (md
, 1, (PTR
) mapto
);
929 #endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
931 /* Returns a section whose range includes PC and SECTION,
932 or NULL if none found. Note the distinction between the return type,
933 struct obj_section (which is defined in gdb), and the input type
934 struct sec (which is a bfd-defined data type). The obj_section
935 contains a pointer to the bfd struct sec section. */
938 find_pc_sect_section (pc
, section
)
942 struct obj_section
*s
;
943 struct objfile
*objfile
;
945 ALL_OBJFILES (objfile
)
946 for (s
= objfile
->sections
; s
< objfile
->sections_end
; ++s
)
947 #if defined(HPUXHPPA)
948 if ((section
== 0 || section
== s
->the_bfd_section
) &&
949 s
->addr
<= pc
&& pc
<= s
->endaddr
)
951 if ((section
== 0 || section
== s
->the_bfd_section
) &&
952 s
->addr
<= pc
&& pc
< s
->endaddr
)
959 /* Returns a section whose range includes PC or NULL if none found.
960 Backward compatibility, no section. */
966 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
970 /* In SVR4, we recognize a trampoline by it's section name.
971 That is, if the pc is in a section named ".plt" then we are in
975 in_plt_section(pc
, name
)
979 struct obj_section
*s
;
982 s
= find_pc_section(pc
);
985 && s
->the_bfd_section
->name
!= NULL
986 && STREQ (s
->the_bfd_section
->name
, ".plt"));