2004-01-19 Andrew Cagney <cagney@redhat.com>
* top.h (mapped_symbol_files): Delete declaration. * main.c (captured_main): Delete option "m" and "mapped". * objfiles.c (mapped_symbol_files): Delete variable. * symfile.c (symbol_file_command): Delete mmap code. (symbol_file_add_with_addrs_or_offsets): Ditto. (add_symbol_file_command, reread_separate_symbols): Ditto. * objfiles.h (OBJF_MAPPED): Delete. * objfiles.c (allocate_objfile) [USE_MMALLOC]: Delete. (free_objfile) [USE_MMALLOC]: Ditto. (open_existing_mapped_file): Delete function. (open_mapped_file): Delete function. (map_to_file): Delete function.
This commit is contained in:
parent
3fe7447286
commit
78a4a9b940
|
@ -1,3 +1,18 @@
|
|||
2004-01-19 Andrew Cagney <cagney@redhat.com>
|
||||
|
||||
* top.h (mapped_symbol_files): Delete declaration.
|
||||
* main.c (captured_main): Delete option "m" and "mapped".
|
||||
* objfiles.c (mapped_symbol_files): Delete variable.
|
||||
* symfile.c (symbol_file_command): Delete mmap code.
|
||||
(symbol_file_add_with_addrs_or_offsets): Ditto.
|
||||
(add_symbol_file_command, reread_separate_symbols): Ditto.
|
||||
* objfiles.h (OBJF_MAPPED): Delete.
|
||||
* objfiles.c (allocate_objfile) [USE_MMALLOC]: Delete.
|
||||
(free_objfile) [USE_MMALLOC]: Ditto.
|
||||
(open_existing_mapped_file): Delete function.
|
||||
(open_mapped_file): Delete function.
|
||||
(map_to_file): Delete function.
|
||||
|
||||
2004-01-19 Kevin Buettner <kevinb@redhat.com>
|
||||
|
||||
* infrun.c (step_into_function): Account for possible breakpoint
|
||||
|
|
|
@ -264,8 +264,6 @@ captured_main (void *data)
|
|||
{"dbx", no_argument, &dbx_commands, 1},
|
||||
{"readnow", no_argument, &readnow_symbol_files, 1},
|
||||
{"r", no_argument, &readnow_symbol_files, 1},
|
||||
{"mapped", no_argument, &mapped_symbol_files, 1},
|
||||
{"m", no_argument, &mapped_symbol_files, 1},
|
||||
{"quiet", no_argument, &quiet, 1},
|
||||
{"q", no_argument, &quiet, 1},
|
||||
{"silent", no_argument, &quiet, 1},
|
||||
|
|
357
gdb/objfiles.c
357
gdb/objfiles.c
|
@ -48,18 +48,6 @@
|
|||
|
||||
/* Prototypes for local functions */
|
||||
|
||||
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
|
||||
|
||||
#include "mmalloc.h"
|
||||
|
||||
static int open_existing_mapped_file (char *, long, int);
|
||||
|
||||
static int open_mapped_file (char *filename, long mtime, int flags);
|
||||
|
||||
static void *map_to_file (int);
|
||||
|
||||
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
|
||||
|
||||
static void objfile_alloc_data (struct objfile *objfile);
|
||||
static void objfile_free_data (struct objfile *objfile);
|
||||
|
||||
|
@ -71,8 +59,6 @@ struct objfile *current_objfile; /* For symbol file being read in */
|
|||
struct objfile *symfile_objfile; /* Main symbol table loaded from */
|
||||
struct objfile *rt_common_objfile; /* For runtime common symbols */
|
||||
|
||||
int mapped_symbol_files; /* Try to use mapped symbol files */
|
||||
|
||||
/* Locate all mappable sections of a BFD file.
|
||||
objfile_p_char is a char * to get it through
|
||||
bfd_map_over_sections; we cast it back to its proper type. */
|
||||
|
@ -150,10 +136,8 @@ build_objfile_section_table (struct objfile *objfile)
|
|||
new objfile struct.
|
||||
|
||||
The FLAGS word contains various bits (OBJF_*) that can be taken as
|
||||
requests for specific operations, like trying to open a mapped
|
||||
version of the objfile (OBJF_MAPPED). Other bits like
|
||||
OBJF_SHARED are simply copied through to the new objfile flags
|
||||
member. */
|
||||
requests for specific operations. Other bits like OBJF_SHARED are
|
||||
simply copied through to the new objfile flags member. */
|
||||
|
||||
/* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
|
||||
by jv-lang.c, to create an artificial objfile used to hold
|
||||
|
@ -170,119 +154,6 @@ allocate_objfile (bfd *abfd, int flags)
|
|||
struct objfile *objfile = NULL;
|
||||
struct objfile *last_one = NULL;
|
||||
|
||||
if (mapped_symbol_files)
|
||||
flags |= OBJF_MAPPED;
|
||||
|
||||
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
|
||||
if (abfd != NULL)
|
||||
{
|
||||
|
||||
/* If we can support mapped symbol files, try to open/reopen the
|
||||
mapped file that corresponds to the file from which we wish to
|
||||
read symbols. If the objfile is to be mapped, we must malloc
|
||||
the structure itself using the mmap version, and arrange that
|
||||
all memory allocation for the objfile uses the mmap routines.
|
||||
If we are reusing an existing mapped file, from which we get
|
||||
our objfile pointer, we have to make sure that we update the
|
||||
pointers to the alloc/free functions in the obstack, in case
|
||||
these functions have moved within the current gdb. */
|
||||
|
||||
int fd;
|
||||
|
||||
fd = open_mapped_file (bfd_get_filename (abfd), bfd_get_mtime (abfd),
|
||||
flags);
|
||||
if (fd >= 0)
|
||||
{
|
||||
void *md;
|
||||
|
||||
if ((md = map_to_file (fd)) == NULL)
|
||||
{
|
||||
close (fd);
|
||||
}
|
||||
else if ((objfile = (struct objfile *) mmalloc_getkey (md, 0)) != NULL)
|
||||
{
|
||||
/* Update memory corruption handler function addresses. */
|
||||
init_malloc (md);
|
||||
objfile->md = md;
|
||||
objfile->mmfd = fd;
|
||||
/* Update pointers to functions to *our* copies */
|
||||
if (objfile->demangled_names_hash)
|
||||
htab_set_functions_ex
|
||||
(objfile->demangled_names_hash, htab_hash_string,
|
||||
(int (*) (const void *, const void *)) streq, NULL,
|
||||
objfile->md, xmcalloc, xmfree);
|
||||
obstack_chunkfun (&objfile->psymbol_cache.cache, xmmalloc);
|
||||
obstack_freefun (&objfile->psymbol_cache.cache, xmfree);
|
||||
obstack_chunkfun (&objfile->macro_cache.cache, xmmalloc);
|
||||
obstack_freefun (&objfile->macro_cache.cache, xmfree);
|
||||
obstack_chunkfun (&objfile->psymbol_obstack, xmmalloc);
|
||||
obstack_freefun (&objfile->psymbol_obstack, xmfree);
|
||||
obstack_chunkfun (&objfile->symbol_obstack, xmmalloc);
|
||||
obstack_freefun (&objfile->symbol_obstack, xmfree);
|
||||
obstack_chunkfun (&objfile->type_obstack, xmmalloc);
|
||||
obstack_freefun (&objfile->type_obstack, xmfree);
|
||||
/* If already in objfile list, unlink it. */
|
||||
unlink_objfile (objfile);
|
||||
/* Forget things specific to a particular gdb, may have changed. */
|
||||
objfile->sf = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
/* Set up to detect internal memory corruption. MUST be
|
||||
done before the first malloc. See comments in
|
||||
init_malloc() and mmcheck(). */
|
||||
|
||||
init_malloc (md);
|
||||
|
||||
objfile = (struct objfile *)
|
||||
xmmalloc (md, sizeof (struct objfile));
|
||||
memset (objfile, 0, sizeof (struct objfile));
|
||||
objfile->md = md;
|
||||
objfile->mmfd = fd;
|
||||
objfile->flags |= OBJF_MAPPED;
|
||||
mmalloc_setkey (objfile->md, 0, objfile);
|
||||
obstack_specify_allocation_with_arg (&objfile->psymbol_cache.cache,
|
||||
0, 0, xmmalloc, xmfree,
|
||||
objfile->md);
|
||||
obstack_specify_allocation_with_arg (&objfile->macro_cache.cache,
|
||||
0, 0, xmmalloc, xmfree,
|
||||
objfile->md);
|
||||
obstack_specify_allocation_with_arg (&objfile->psymbol_obstack,
|
||||
0, 0, xmmalloc, xmfree,
|
||||
objfile->md);
|
||||
obstack_specify_allocation_with_arg (&objfile->symbol_obstack,
|
||||
0, 0, xmmalloc, xmfree,
|
||||
objfile->md);
|
||||
obstack_specify_allocation_with_arg (&objfile->type_obstack,
|
||||
0, 0, xmmalloc, xmfree,
|
||||
objfile->md);
|
||||
}
|
||||
}
|
||||
|
||||
if ((flags & OBJF_MAPPED) && (objfile == NULL))
|
||||
{
|
||||
warning ("symbol table for '%s' will not be mapped",
|
||||
bfd_get_filename (abfd));
|
||||
flags &= ~OBJF_MAPPED;
|
||||
}
|
||||
}
|
||||
#else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
|
||||
|
||||
if (flags & OBJF_MAPPED)
|
||||
{
|
||||
warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
|
||||
|
||||
/* Turn off the global flag so we don't try to do mapped symbol tables
|
||||
any more, which shuts up gdb unless the user specifically gives the
|
||||
"mapped" keyword again. */
|
||||
|
||||
mapped_symbol_files = 0;
|
||||
flags &= ~OBJF_MAPPED;
|
||||
}
|
||||
|
||||
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
|
||||
|
||||
/* If we don't support mapped symbol files, didn't ask for the file to be
|
||||
mapped, or failed to open the mapped file for some reason, then revert
|
||||
back to an unmapped objfile. */
|
||||
|
@ -300,7 +171,6 @@ allocate_objfile (bfd *abfd, int flags)
|
|||
xfree);
|
||||
obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
|
||||
xfree);
|
||||
flags &= ~OBJF_MAPPED;
|
||||
|
||||
terminate_minimal_symbol_table (objfile);
|
||||
}
|
||||
|
@ -545,52 +415,27 @@ free_objfile (struct objfile *objfile)
|
|||
to call this here. */
|
||||
clear_pc_function_cache ();
|
||||
|
||||
/* The last thing we do is free the objfile struct itself for the
|
||||
non-reusable case, or detach from the mapped file for the
|
||||
reusable case. Note that the mmalloc_detach or the xmfree() is
|
||||
the last thing we can do with this objfile. */
|
||||
/* The last thing we do is free the objfile struct itself. */
|
||||
|
||||
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
|
||||
|
||||
if (objfile->flags & OBJF_MAPPED)
|
||||
objfile_free_data (objfile);
|
||||
if (objfile->name != NULL)
|
||||
{
|
||||
/* Remember the fd so we can close it. We can't close it before
|
||||
doing the detach, and after the detach the objfile is gone. */
|
||||
int mmfd;
|
||||
|
||||
mmfd = objfile->mmfd;
|
||||
mmalloc_detach (objfile->md);
|
||||
objfile = NULL;
|
||||
close (mmfd);
|
||||
}
|
||||
|
||||
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
|
||||
|
||||
/* If we still have an objfile, then either we don't support reusable
|
||||
objfiles or this one was not reusable. So free it normally. */
|
||||
|
||||
if (objfile != NULL)
|
||||
{
|
||||
objfile_free_data (objfile);
|
||||
if (objfile->name != NULL)
|
||||
{
|
||||
xmfree (objfile->md, objfile->name);
|
||||
}
|
||||
if (objfile->global_psymbols.list)
|
||||
xmfree (objfile->md, objfile->global_psymbols.list);
|
||||
if (objfile->static_psymbols.list)
|
||||
xmfree (objfile->md, objfile->static_psymbols.list);
|
||||
/* Free the obstacks for non-reusable objfiles */
|
||||
bcache_xfree (objfile->psymbol_cache);
|
||||
bcache_xfree (objfile->macro_cache);
|
||||
if (objfile->demangled_names_hash)
|
||||
htab_delete (objfile->demangled_names_hash);
|
||||
obstack_free (&objfile->psymbol_obstack, 0);
|
||||
obstack_free (&objfile->symbol_obstack, 0);
|
||||
obstack_free (&objfile->type_obstack, 0);
|
||||
xmfree (objfile->md, objfile);
|
||||
objfile = NULL;
|
||||
xmfree (objfile->md, objfile->name);
|
||||
}
|
||||
if (objfile->global_psymbols.list)
|
||||
xmfree (objfile->md, objfile->global_psymbols.list);
|
||||
if (objfile->static_psymbols.list)
|
||||
xmfree (objfile->md, objfile->static_psymbols.list);
|
||||
/* Free the obstacks for non-reusable objfiles */
|
||||
bcache_xfree (objfile->psymbol_cache);
|
||||
bcache_xfree (objfile->macro_cache);
|
||||
if (objfile->demangled_names_hash)
|
||||
htab_delete (objfile->demangled_names_hash);
|
||||
obstack_free (&objfile->psymbol_obstack, 0);
|
||||
obstack_free (&objfile->symbol_obstack, 0);
|
||||
obstack_free (&objfile->type_obstack, 0);
|
||||
xmfree (objfile->md, objfile);
|
||||
objfile = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -882,168 +727,6 @@ have_minimal_symbols (void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
|
||||
|
||||
/* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
|
||||
of the corresponding symbol file in MTIME, try to open an existing file
|
||||
with the name SYMSFILENAME and verify it is more recent than the base
|
||||
file by checking it's timestamp against MTIME.
|
||||
|
||||
If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
|
||||
|
||||
If SYMSFILENAME does exist, but is out of date, we check to see if the
|
||||
user has specified creation of a mapped file. If so, we don't issue
|
||||
any warning message because we will be creating a new mapped file anyway,
|
||||
overwriting the old one. If not, then we issue a warning message so that
|
||||
the user will know why we aren't using this existing mapped symbol file.
|
||||
In either case, we return -1.
|
||||
|
||||
If SYMSFILENAME does exist and is not out of date, but can't be opened for
|
||||
some reason, then prints an appropriate system error message and returns -1.
|
||||
|
||||
Otherwise, returns the open file descriptor. */
|
||||
|
||||
static int
|
||||
open_existing_mapped_file (char *symsfilename, long mtime, int flags)
|
||||
{
|
||||
int fd = -1;
|
||||
struct stat sbuf;
|
||||
|
||||
if (stat (symsfilename, &sbuf) == 0)
|
||||
{
|
||||
if (sbuf.st_mtime < mtime)
|
||||
{
|
||||
if (!(flags & OBJF_MAPPED))
|
||||
{
|
||||
warning ("mapped symbol file `%s' is out of date, ignored it",
|
||||
symsfilename);
|
||||
}
|
||||
}
|
||||
else if ((fd = open (symsfilename, O_RDWR)) < 0)
|
||||
{
|
||||
if (error_pre_print)
|
||||
{
|
||||
printf_unfiltered (error_pre_print);
|
||||
}
|
||||
print_sys_errmsg (symsfilename, errno);
|
||||
}
|
||||
}
|
||||
return (fd);
|
||||
}
|
||||
|
||||
/* Look for a mapped symbol file that corresponds to FILENAME and is more
|
||||
recent than MTIME. If MAPPED is nonzero, the user has asked that gdb
|
||||
use a mapped symbol file for this file, so create a new one if one does
|
||||
not currently exist.
|
||||
|
||||
If found, then return an open file descriptor for the file, otherwise
|
||||
return -1.
|
||||
|
||||
This routine is responsible for implementing the policy that generates
|
||||
the name of the mapped symbol file from the name of a file containing
|
||||
symbols that gdb would like to read. Currently this policy is to append
|
||||
".syms" to the name of the file.
|
||||
|
||||
This routine is also responsible for implementing the policy that
|
||||
determines where the mapped symbol file is found (the search path).
|
||||
This policy is that when reading an existing mapped file, a file of
|
||||
the correct name in the current directory takes precedence over a
|
||||
file of the correct name in the same directory as the symbol file.
|
||||
When creating a new mapped file, it is always created in the current
|
||||
directory. This helps to minimize the chances of a user unknowingly
|
||||
creating big mapped files in places like /bin and /usr/local/bin, and
|
||||
allows a local copy to override a manually installed global copy (in
|
||||
/bin for example). */
|
||||
|
||||
static int
|
||||
open_mapped_file (char *filename, long mtime, int flags)
|
||||
{
|
||||
int fd;
|
||||
char *symsfilename;
|
||||
|
||||
/* First try to open an existing file in the current directory, and
|
||||
then try the directory where the symbol file is located. */
|
||||
|
||||
symsfilename = concat ("./", lbasename (filename), ".syms", (char *) NULL);
|
||||
if ((fd = open_existing_mapped_file (symsfilename, mtime, flags)) < 0)
|
||||
{
|
||||
xfree (symsfilename);
|
||||
symsfilename = concat (filename, ".syms", (char *) NULL);
|
||||
fd = open_existing_mapped_file (symsfilename, mtime, flags);
|
||||
}
|
||||
|
||||
/* If we don't have an open file by now, then either the file does not
|
||||
already exist, or the base file has changed since it was created. In
|
||||
either case, if the user has specified use of a mapped file, then
|
||||
create a new mapped file, truncating any existing one. If we can't
|
||||
create one, print a system error message saying why we can't.
|
||||
|
||||
By default the file is rw for everyone, with the user's umask taking
|
||||
care of turning off the permissions the user wants off. */
|
||||
|
||||
if ((fd < 0) && (flags & OBJF_MAPPED))
|
||||
{
|
||||
xfree (symsfilename);
|
||||
symsfilename = concat ("./", lbasename (filename), ".syms",
|
||||
(char *) NULL);
|
||||
if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
|
||||
{
|
||||
if (error_pre_print)
|
||||
{
|
||||
printf_unfiltered (error_pre_print);
|
||||
}
|
||||
print_sys_errmsg (symsfilename, errno);
|
||||
}
|
||||
}
|
||||
|
||||
xfree (symsfilename);
|
||||
return (fd);
|
||||
}
|
||||
|
||||
static void *
|
||||
map_to_file (int fd)
|
||||
{
|
||||
void *md;
|
||||
CORE_ADDR mapto;
|
||||
|
||||
md = mmalloc_attach (fd, 0);
|
||||
if (md != NULL)
|
||||
{
|
||||
mapto = (CORE_ADDR) mmalloc_getkey (md, 1);
|
||||
md = mmalloc_detach (md);
|
||||
if (md != NULL)
|
||||
{
|
||||
/* FIXME: should figure out why detach failed */
|
||||
md = NULL;
|
||||
}
|
||||
else if (mapto != (CORE_ADDR) NULL)
|
||||
{
|
||||
/* This mapping file needs to be remapped at "mapto" */
|
||||
md = mmalloc_attach (fd, mapto);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* This is a freshly created mapping file. */
|
||||
mapto = (CORE_ADDR) mmalloc_findbase (20 * 1024 * 1024);
|
||||
if (mapto != 0)
|
||||
{
|
||||
/* To avoid reusing the freshly created mapping file, at the
|
||||
address selected by mmap, we must truncate it before trying
|
||||
to do an attach at the address we want. */
|
||||
ftruncate (fd, 0);
|
||||
md = mmalloc_attach (fd, mapto);
|
||||
if (md != NULL)
|
||||
{
|
||||
mmalloc_setkey (md, 1, mapto);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return (md);
|
||||
}
|
||||
|
||||
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
|
||||
|
||||
/* Returns a section whose range includes PC and SECTION, or NULL if
|
||||
none found. Note the distinction between the return type, struct
|
||||
obj_section (which is defined in gdb), and the input type "struct
|
||||
|
|
|
@ -470,15 +470,6 @@ struct objfile
|
|||
|
||||
/* Defines for the objfile flag word. */
|
||||
|
||||
/* Gdb can arrange to allocate storage for all objects related to a
|
||||
particular objfile in a designated section of its address space,
|
||||
managed at a low level by mmap() and using a special version of
|
||||
malloc that handles malloc/free/realloc on top of the mmap() interface.
|
||||
This allows the "internal gdb state" for a particular objfile to be
|
||||
dumped to a gdb state file and subsequently reloaded at a later time. */
|
||||
|
||||
#define OBJF_MAPPED (1 << 0) /* Objfile data is mmap'd */
|
||||
|
||||
/* When using mapped/remapped predigested gdb symbol information, we need
|
||||
a flag that indicates that we have previously done an initial symbol
|
||||
table read from this particular objfile. We can't just look for the
|
||||
|
|
|
@ -847,43 +847,22 @@ symbol_file_add_with_addrs_or_offsets (char *name, int from_tty,
|
|||
orig_addrs->other[i] = addrs->other[i];
|
||||
}
|
||||
|
||||
/* If the objfile uses a mapped symbol file, and we have a psymtab for
|
||||
it, then skip reading any symbols at this time. */
|
||||
|
||||
if ((objfile->flags & OBJF_MAPPED) && (objfile->flags & OBJF_SYMS))
|
||||
/* We either created a new mapped symbol table, mapped an existing
|
||||
symbol table file which has not had initial symbol reading
|
||||
performed, or need to read an unmapped symbol table. */
|
||||
if (from_tty || info_verbose)
|
||||
{
|
||||
/* We mapped in an existing symbol table file that already has had
|
||||
initial symbol reading performed, so we can skip that part. Notify
|
||||
the user that instead of reading the symbols, they have been mapped.
|
||||
*/
|
||||
if (from_tty || info_verbose)
|
||||
if (pre_add_symbol_hook)
|
||||
pre_add_symbol_hook (name);
|
||||
else
|
||||
{
|
||||
printf_unfiltered ("Mapped symbols for %s...", name);
|
||||
printf_unfiltered ("Reading symbols from %s...", name);
|
||||
wrap_here ("");
|
||||
gdb_flush (gdb_stdout);
|
||||
}
|
||||
init_entry_point_info (objfile);
|
||||
find_sym_fns (objfile);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* We either created a new mapped symbol table, mapped an existing
|
||||
symbol table file which has not had initial symbol reading
|
||||
performed, or need to read an unmapped symbol table. */
|
||||
if (from_tty || info_verbose)
|
||||
{
|
||||
if (pre_add_symbol_hook)
|
||||
pre_add_symbol_hook (name);
|
||||
else
|
||||
{
|
||||
printf_unfiltered ("Reading symbols from %s...", name);
|
||||
wrap_here ("");
|
||||
gdb_flush (gdb_stdout);
|
||||
}
|
||||
}
|
||||
syms_from_objfile (objfile, addrs, offsets, num_offsets,
|
||||
mainline, from_tty);
|
||||
}
|
||||
syms_from_objfile (objfile, addrs, offsets, num_offsets,
|
||||
mainline, from_tty);
|
||||
|
||||
/* We now have at least a partial symbol table. Check to see if the
|
||||
user requested that all symbols be read on initial access via either
|
||||
|
@ -1209,20 +1188,16 @@ symbol_file_command (char *args, int from_tty)
|
|||
cleanups = make_cleanup_freeargv (argv);
|
||||
while (*argv != NULL)
|
||||
{
|
||||
if (strcmp (*argv, "-mapped") == 0)
|
||||
flags |= OBJF_MAPPED;
|
||||
else
|
||||
if (strcmp (*argv, "-readnow") == 0)
|
||||
flags |= OBJF_READNOW;
|
||||
else
|
||||
if (**argv == '-')
|
||||
error ("unknown option `%s'", *argv);
|
||||
else
|
||||
{
|
||||
name = *argv;
|
||||
|
||||
symbol_file_add_main_1 (name, from_tty, flags);
|
||||
}
|
||||
if (strcmp (*argv, "-readnow") == 0)
|
||||
flags |= OBJF_READNOW;
|
||||
else if (**argv == '-')
|
||||
error ("unknown option `%s'", *argv);
|
||||
else
|
||||
{
|
||||
name = *argv;
|
||||
|
||||
symbol_file_add_main_1 (name, from_tty, flags);
|
||||
}
|
||||
argv++;
|
||||
}
|
||||
|
||||
|
@ -1737,17 +1712,13 @@ add_symbol_file_command (char *args, int from_tty)
|
|||
|
||||
if (*arg == '-')
|
||||
{
|
||||
if (strcmp (arg, "-mapped") == 0)
|
||||
flags |= OBJF_MAPPED;
|
||||
else
|
||||
if (strcmp (arg, "-readnow") == 0)
|
||||
flags |= OBJF_READNOW;
|
||||
else
|
||||
if (strcmp (arg, "-s") == 0)
|
||||
{
|
||||
expecting_sec_name = 1;
|
||||
expecting_sec_addr = 1;
|
||||
}
|
||||
if (strcmp (arg, "-readnow") == 0)
|
||||
flags |= OBJF_READNOW;
|
||||
else if (strcmp (arg, "-s") == 0)
|
||||
{
|
||||
expecting_sec_name = 1;
|
||||
expecting_sec_addr = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -2096,8 +2067,7 @@ reread_separate_symbols (struct objfile *objfile)
|
|||
0, /* No addr table. */
|
||||
objfile->section_offsets, objfile->num_sections,
|
||||
0, /* Not mainline. See comments about this above. */
|
||||
objfile->flags & (OBJF_MAPPED | OBJF_REORDERED
|
||||
| OBJF_SHARED | OBJF_READNOW
|
||||
objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW
|
||||
| OBJF_USERLOADED)));
|
||||
objfile->separate_debug_objfile->separate_debug_objfile_backlink
|
||||
= objfile;
|
||||
|
|
Loading…
Reference in New Issue