along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include "arch-utils.h"
#include "bfdlink.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "language.h"
#include "complaints.h"
#include "demangle.h"
-#include "inferior.h" /* for write_pc */
+#include "inferior.h"
+#include "regcache.h"
#include "filenames.h" /* for DOSish file names */
#include "gdb-stabs.h"
#include "gdb_obstack.h"
static void add_symbol_file_command (char *, int);
-static void add_shared_symbol_files_command (char *, int);
-
static void reread_separate_symbols (struct objfile *objfile);
static void cashier_psymtab (struct partial_symtab *);
static void simple_free_overlay_table (void);
-static void read_target_long_array (CORE_ADDR, unsigned int *, int);
+static void read_target_long_array (CORE_ADDR, unsigned int *, int, int,
+ enum bfd_endian);
static int simple_read_overlay_table (void);
value);
}
-/* If non-zero, gdb will notify the user when it is loading symbols
- from a file. This is almost always what users will want to have happen;
- but for programs with lots of dynamically linked libraries, the output
- can be more noise than signal. */
-
-int print_symbol_loading = 1;
-
/* If non-zero, shared library symbols will be added automatically
when the inferior is created, new libraries are loaded, or when
attaching to the inferior. This is almost always what users will
an existing section table. */
extern struct section_addr_info *
-build_section_addr_info_from_section_table (const struct section_table *start,
- const struct section_table *end)
+build_section_addr_info_from_section_table (const struct target_section *start,
+ const struct target_section *end)
{
struct section_addr_info *sap;
- const struct section_table *stp;
+ const struct target_section *stp;
int oidx;
sap = alloc_section_addr_info (end - start);
/* Find a unique offset to use for loadable section SECT if
the user did not provide an offset. */
-void
+static void
place_section (bfd *abfd, asection *sect, void *obj)
{
struct place_section_arg *arg = obj;
list any more; all we have is the section offset table.) If
OFFSETS is non-zero, ADDRS must be zero.
- MAINLINE is nonzero if this is the main symbol file, or zero if
- it's an extra symbol file such as dynamically loaded code.
-
- VERBO is nonzero if the caller has printed a verbose message about
- the symbol reading (and complaints can be more terse about it). */
+ ADD_FLAGS encodes verbosity level, whether this is main symbol or
+ an extra symbol file such as dynamically loaded code, and wether
+ breakpoint reset should be deferred. */
void
syms_from_objfile (struct objfile *objfile,
struct section_addr_info *addrs,
struct section_offsets *offsets,
int num_offsets,
- int mainline,
- int verbo)
+ int add_flags)
{
struct section_addr_info *local_addr = NULL;
struct cleanup *old_chain;
+ const int mainline = add_flags & SYMFILE_MAINLINE;
gdb_assert (! (addrs && offsets));
if (symfile_objfile != NULL)
{
free_objfile (symfile_objfile);
- symfile_objfile = NULL;
+ gdb_assert (symfile_objfile == NULL);
}
/* Currently we keep symbols from the add-symbol-file command.
initial symbol reading for this file. */
(*objfile->sf->sym_init) (objfile);
- clear_complaints (&symfile_complaints, 1, verbo);
+ clear_complaints (&symfile_complaints, 1, add_flags & SYMFILE_VERBOSE);
if (addrs)
(*objfile->sf->sym_offsets) (objfile, addrs);
objfile. */
void
-new_symfile_objfile (struct objfile *objfile, int mainline, int verbo)
+new_symfile_objfile (struct objfile *objfile, int add_flags)
{
/* If this is the main symbol file we have to clean up all users of the
old main symbol file. Otherwise it is sufficient to fixup all the
breakpoints that may have been redefined by this symbol file. */
- if (mainline)
+ if (add_flags & SYMFILE_MAINLINE)
{
/* OK, make it the "real" symbol file. */
symfile_objfile = objfile;
clear_symtab_users ();
}
- else
+ else if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
{
breakpoint_re_set ();
}
/* We're done reading the symbol file; finish off complaints. */
- clear_complaints (&symfile_complaints, 0, verbo);
+ clear_complaints (&symfile_complaints, 0, add_flags & SYMFILE_VERBOSE);
}
/* Process a symbol file, as either the main file or as a dynamically
ABFD is a BFD already open on the file, as from symfile_bfd_open.
This BFD will be closed on error, and is always consumed by this function.
- FROM_TTY says how verbose to be.
-
- MAINLINE specifies whether this is the main symbol file, or whether
- it's an extra symbol file such as dynamically loaded code.
+ ADD_FLAGS encodes verbosity, whether this is main symbol file or
+ extra, such as dynamically loaded code, and what to do with breakpoins.
ADDRS, OFFSETS, and NUM_OFFSETS are as described for
- syms_from_objfile, above. ADDRS is ignored when MAINLINE is
- non-zero.
+ syms_from_objfile, above.
+ ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
Upon success, returns a pointer to the objfile that was added.
Upon failure, jumps back to command level (never returns). */
+
static struct objfile *
-symbol_file_add_with_addrs_or_offsets (bfd *abfd, int from_tty,
+symbol_file_add_with_addrs_or_offsets (bfd *abfd,
+ int add_flags,
struct section_addr_info *addrs,
struct section_offsets *offsets,
int num_offsets,
- int mainline, int flags)
+ int flags)
{
struct objfile *objfile;
struct partial_symtab *psymtab;
struct section_addr_info *orig_addrs = NULL;
struct cleanup *my_cleanups;
const char *name = bfd_get_filename (abfd);
+ const int from_tty = add_flags & SYMFILE_VERBOSE;
my_cleanups = make_cleanup_bfd_close (abfd);
interactively wiping out any existing symbols. */
if ((have_full_symbols () || have_partial_symbols ())
- && mainline
+ && (add_flags & SYMFILE_MAINLINE)
&& from_tty
- && !query ("Load new symbol table from \"%s\"? ", name))
+ && !query (_("Load new symbol table from \"%s\"? "), name))
error (_("Not confirmed."));
objfile = allocate_objfile (abfd, flags);
deprecated_pre_add_symbol_hook (name);
else
{
- if (print_symbol_loading)
- {
- printf_unfiltered (_("Reading symbols from %s..."), name);
- wrap_here ("");
- gdb_flush (gdb_stdout);
- }
+ printf_unfiltered (_("Reading symbols from %s..."), name);
+ wrap_here ("");
+ gdb_flush (gdb_stdout);
}
}
syms_from_objfile (objfile, addrs, offsets, num_offsets,
- mainline, from_tty);
+ add_flags);
/* 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
if ((flags & OBJF_READNOW) || readnow_symbol_files)
{
- if ((from_tty || info_verbose) && print_symbol_loading)
+ if (from_tty || info_verbose)
{
printf_unfiltered (_("expanding to full symbols..."));
wrap_here ("");
if (addrs != NULL)
{
objfile->separate_debug_objfile
- = symbol_file_add (debugfile, from_tty, orig_addrs, 0, flags);
+ = symbol_file_add (debugfile, add_flags, orig_addrs, flags);
}
else
{
objfile->separate_debug_objfile
- = symbol_file_add (debugfile, from_tty, NULL, 0, flags);
+ = symbol_file_add (debugfile, add_flags, NULL, flags);
}
objfile->separate_debug_objfile->separate_debug_objfile_backlink
= objfile;
xfree (debugfile);
}
- if (!have_partial_symbols () && !have_full_symbols ()
- && print_symbol_loading)
+ if ((from_tty || info_verbose)
+ && !objfile_has_symbols (objfile))
{
wrap_here ("");
- printf_unfiltered (_("(no debugging symbols found)"));
- if (from_tty || info_verbose)
- printf_unfiltered ("...");
- else
- printf_unfiltered ("\n");
+ printf_unfiltered (_("(no debugging symbols found)..."));
wrap_here ("");
}
if (deprecated_post_add_symbol_hook)
deprecated_post_add_symbol_hook ();
else
- {
- if (print_symbol_loading)
- printf_unfiltered (_("done.\n"));
- }
+ printf_unfiltered (_("done.\n"));
}
/* We print some messages regardless of whether 'from_tty ||
do_cleanups (my_cleanups);
if (objfile->sf == NULL)
- return objfile; /* No symbols. */
+ {
+ observer_notify_new_objfile (objfile);
+ return objfile; /* No symbols. */
+ }
- new_symfile_objfile (objfile, mainline, from_tty);
+ new_symfile_objfile (objfile, add_flags);
observer_notify_new_objfile (objfile);
See symbol_file_add_with_addrs_or_offsets's comments for
details. */
struct objfile *
-symbol_file_add_from_bfd (bfd *abfd, int from_tty,
+symbol_file_add_from_bfd (bfd *abfd, int add_flags,
struct section_addr_info *addrs,
- int mainline, int flags)
+ int flags)
{
- return symbol_file_add_with_addrs_or_offsets (abfd,
- from_tty, addrs, 0, 0,
- mainline, flags);
+ return symbol_file_add_with_addrs_or_offsets (abfd, add_flags, addrs, 0, 0,
+ flags);
}
loaded file. See symbol_file_add_with_addrs_or_offsets's comments
for details. */
struct objfile *
-symbol_file_add (char *name, int from_tty, struct section_addr_info *addrs,
- int mainline, int flags)
+symbol_file_add (char *name, int add_flags, struct section_addr_info *addrs,
+ int flags)
{
- return symbol_file_add_from_bfd (symfile_bfd_open (name), from_tty,
- addrs, mainline, flags);
+ return symbol_file_add_from_bfd (symfile_bfd_open (name), add_flags, addrs,
+ flags);
}
static void
symbol_file_add_main_1 (char *args, int from_tty, int flags)
{
- symbol_file_add (args, from_tty, NULL, 1, flags);
+ const int add_flags = SYMFILE_MAINLINE | (from_tty ? SYMFILE_VERBOSE : 0);
+ symbol_file_add (args, add_flags, NULL, flags);
/* Getting new symbols may change our opinion about
what is frameless. */
symfile_objfile->name)
: !query (_("Discard symbol table? "))))
error (_("Not confirmed."));
- free_all_objfiles ();
- /* solib descriptors may have handles to objfiles. Since their
- storage has just been released, we'd better wipe the solib
- descriptors as well.
- */
- no_shared_libraries (NULL, from_tty);
+ free_all_objfiles ();
- symfile_objfile = NULL;
- if (from_tty)
- printf_unfiltered (_("No symbol file now.\n"));
+ /* solib descriptors may have handles to objfiles. Since their
+ storage has just been released, we'd better wipe the solib
+ descriptors as well. */
+ no_shared_libraries (NULL, from_tty);
+
+ gdb_assert (symfile_objfile == NULL);
+ if (from_tty)
+ printf_unfiltered (_("No symbol file now.\n"));
}
struct build_id
static char *
build_id_to_debug_filename (struct build_id *build_id)
{
- char *link, *s, *retval = NULL;
- gdb_byte *data = build_id->data;
- size_t size = build_id->size;
+ char *link, *debugdir, *retval = NULL;
/* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
- link = xmalloc (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
- + 2 * size + (sizeof ".debug" - 1) + 1);
- s = link + sprintf (link, "%s/.build-id/", debug_file_directory);
- if (size > 0)
- {
- size--;
- s += sprintf (s, "%02x", (unsigned) *data++);
- }
- if (size > 0)
- *s++ = '/';
- while (size-- > 0)
- s += sprintf (s, "%02x", (unsigned) *data++);
- strcpy (s, ".debug");
-
- /* lrealpath() is expensive even for the usually non-existent files. */
- if (access (link, F_OK) == 0)
- retval = lrealpath (link);
- xfree (link);
-
- if (retval != NULL && !build_id_verify (retval, build_id))
+ link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
+ + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
+
+ /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
+ cause "/.build-id/..." lookups. */
+
+ debugdir = debug_file_directory;
+ do
{
- xfree (retval);
- retval = NULL;
+ char *s, *debugdir_end;
+ gdb_byte *data = build_id->data;
+ size_t size = build_id->size;
+
+ while (*debugdir == DIRNAME_SEPARATOR)
+ debugdir++;
+
+ debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
+ if (debugdir_end == NULL)
+ debugdir_end = &debugdir[strlen (debugdir)];
+
+ memcpy (link, debugdir, debugdir_end - debugdir);
+ s = &link[debugdir_end - debugdir];
+ s += sprintf (s, "/.build-id/");
+ if (size > 0)
+ {
+ size--;
+ s += sprintf (s, "%02x", (unsigned) *data++);
+ }
+ if (size > 0)
+ *s++ = '/';
+ while (size-- > 0)
+ s += sprintf (s, "%02x", (unsigned) *data++);
+ strcpy (s, ".debug");
+
+ /* lrealpath() is expensive even for the usually non-existent files. */
+ if (access (link, F_OK) == 0)
+ retval = lrealpath (link);
+
+ if (retval != NULL && !build_id_verify (retval, build_id))
+ {
+ xfree (retval);
+ retval = NULL;
+ }
+
+ if (retval != NULL)
+ break;
+
+ debugdir = debugdir_end;
}
+ while (*debugdir != 0);
return retval;
}
}
static int
-separate_debug_file_exists (const char *name, unsigned long crc)
+separate_debug_file_exists (const char *name, unsigned long crc,
+ struct objfile *parent_objfile)
{
unsigned long file_crc = 0;
bfd *abfd;
gdb_byte buffer[8*1024];
int count;
+ struct stat parent_stat, abfd_stat;
+
+ /* Find a separate debug info file as if symbols would be present in
+ PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
+ section can contain just the basename of PARENT_OBJFILE without any
+ ".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
+ the separate debug infos with the same basename can exist. */
+
+ if (strcmp (name, parent_objfile->name) == 0)
+ return 0;
if (remote_filename_p (name))
abfd = remote_bfd_open (name, gnutarget);
if (!abfd)
return 0;
+ /* Verify symlinks were not the cause of strcmp name difference above.
+
+ Some operating systems, e.g. Windows, do not provide a meaningful
+ st_ino; they always set it to zero. (Windows does provide a
+ meaningful st_dev.) Do not indicate a duplicate library in that
+ case. While there is no guarantee that a system that provides
+ meaningful inode numbers will never set st_ino to zero, this is
+ merely an optimization, so we do not need to worry about false
+ negatives. */
+
+ if (bfd_stat (abfd, &abfd_stat) == 0
+ && bfd_stat (parent_objfile->obfd, &parent_stat) == 0
+ && abfd_stat.st_dev == parent_stat.st_dev
+ && abfd_stat.st_ino == parent_stat.st_ino
+ && abfd_stat.st_ino != 0)
+ {
+ bfd_close (abfd);
+ return 0;
+ }
+
while ((count = bfd_bread (buffer, sizeof (buffer), abfd)) > 0)
file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
bfd_close (abfd);
- return crc == file_crc;
+ if (crc != file_crc)
+ {
+ warning (_("the debug information found in \"%s\""
+ " does not match \"%s\" (CRC mismatch).\n"),
+ name, parent_objfile->name);
+ return 0;
+ }
+
+ return 1;
}
char *debug_file_directory = NULL;
find_separate_debug_file (struct objfile *objfile)
{
asection *sect;
- char *basename;
- char *dir;
- char *debugfile;
- char *name_copy;
- char *canon_name;
+ char *basename, *name_copy, *debugdir;
+ char *dir = NULL;
+ char *debugfile = NULL;
+ char *canon_name = NULL;
bfd_size_type debuglink_size;
unsigned long crc32;
int i;
basename = get_debug_link_info (objfile, &crc32);
if (basename == NULL)
- return NULL;
+ /* There's no separate debug info, hence there's no way we could
+ load it => no warning. */
+ goto cleanup_return_debugfile;
dir = xstrdup (objfile->name);
gdb_assert (i >= 0 && IS_DIR_SEPARATOR (dir[i]));
dir[i+1] = '\0';
- debugfile = alloca (strlen (debug_file_directory) + 1
- + strlen (dir)
- + strlen (DEBUG_SUBDIRECTORY)
- + strlen ("/")
- + strlen (basename)
- + 1);
+ /* Set I to max (strlen (canon_name), strlen (dir)). */
+ canon_name = lrealpath (dir);
+ i = strlen (dir);
+ if (canon_name && strlen (canon_name) > i)
+ i = strlen (canon_name);
+
+ debugfile = xmalloc (strlen (debug_file_directory) + 1
+ + i
+ + strlen (DEBUG_SUBDIRECTORY)
+ + strlen ("/")
+ + strlen (basename)
+ + 1);
/* First try in the same directory as the original file. */
strcpy (debugfile, dir);
strcat (debugfile, basename);
- if (separate_debug_file_exists (debugfile, crc32))
- {
- xfree (basename);
- xfree (dir);
- return xstrdup (debugfile);
- }
+ if (separate_debug_file_exists (debugfile, crc32, objfile))
+ goto cleanup_return_debugfile;
/* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
strcpy (debugfile, dir);
strcat (debugfile, "/");
strcat (debugfile, basename);
- if (separate_debug_file_exists (debugfile, crc32))
- {
- xfree (basename);
- xfree (dir);
- return xstrdup (debugfile);
- }
+ if (separate_debug_file_exists (debugfile, crc32, objfile))
+ goto cleanup_return_debugfile;
- /* Then try in the global debugfile directory. */
- strcpy (debugfile, debug_file_directory);
- strcat (debugfile, "/");
- strcat (debugfile, dir);
- strcat (debugfile, basename);
+ /* Then try in the global debugfile directories.
+
+ Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
+ cause "/..." lookups. */
- if (separate_debug_file_exists (debugfile, crc32))
+ debugdir = debug_file_directory;
+ do
{
- xfree (basename);
- xfree (dir);
- return xstrdup (debugfile);
- }
+ char *debugdir_end;
- /* If the file is in the sysroot, try using its base path in the
- global debugfile directory. */
- canon_name = lrealpath (dir);
- if (canon_name
- && strncmp (canon_name, gdb_sysroot, strlen (gdb_sysroot)) == 0
- && IS_DIR_SEPARATOR (canon_name[strlen (gdb_sysroot)]))
- {
- strcpy (debugfile, debug_file_directory);
- strcat (debugfile, canon_name + strlen (gdb_sysroot));
+ while (*debugdir == DIRNAME_SEPARATOR)
+ debugdir++;
+
+ debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
+ if (debugdir_end == NULL)
+ debugdir_end = &debugdir[strlen (debugdir)];
+
+ memcpy (debugfile, debugdir, debugdir_end - debugdir);
+ debugfile[debugdir_end - debugdir] = 0;
strcat (debugfile, "/");
+ strcat (debugfile, dir);
strcat (debugfile, basename);
- if (separate_debug_file_exists (debugfile, crc32))
+ if (separate_debug_file_exists (debugfile, crc32, objfile))
+ goto cleanup_return_debugfile;
+
+ /* If the file is in the sysroot, try using its base path in the
+ global debugfile directory. */
+ if (canon_name
+ && strncmp (canon_name, gdb_sysroot, strlen (gdb_sysroot)) == 0
+ && IS_DIR_SEPARATOR (canon_name[strlen (gdb_sysroot)]))
{
- xfree (canon_name);
- xfree (basename);
- xfree (dir);
- return xstrdup (debugfile);
+ memcpy (debugfile, debugdir, debugdir_end - debugdir);
+ debugfile[debugdir_end - debugdir] = 0;
+ strcat (debugfile, canon_name + strlen (gdb_sysroot));
+ strcat (debugfile, "/");
+ strcat (debugfile, basename);
+
+ if (separate_debug_file_exists (debugfile, crc32, objfile))
+ goto cleanup_return_debugfile;
}
+
+ debugdir = debugdir_end;
}
+ while (*debugdir != 0);
- if (canon_name)
- xfree (canon_name);
+ xfree (debugfile);
+ debugfile = NULL;
+cleanup_return_debugfile:
+ xfree (canon_name);
xfree (basename);
xfree (dir);
- return NULL;
+ return debugfile;
}
/* Look down path for it, allocate 2nd new malloc'd copy. */
desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, name,
- O_RDONLY | O_BINARY, 0, &absolute_name);
+ O_RDONLY | O_BINARY, &absolute_name);
#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
if (desc < 0)
{
char *exename = alloca (strlen (name) + 5);
strcat (strcpy (exename, name), ".exe");
desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
- O_RDONLY | O_BINARY, 0, &absolute_name);
+ O_RDONLY | O_BINARY, &absolute_name);
}
#endif
if (desc < 0)
bfd_errmsg (bfd_get_error ()));
}
+ /* bfd_usrdata exists for applications and libbfd must not touch it. */
+ gdb_assert (bfd_usrdata (sym_bfd) == NULL);
+
return sym_bfd;
}
{
/* The write is just starting. Let the user know we've started
this section. */
- ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
- args->section_name, paddr_nz (args->section_size),
- paddr_nz (args->lma));
+ ui_out_message (uiout, 0, "Loading section %s, size %s lma %s\n",
+ args->section_name, hex_string (args->section_size),
+ paddress (target_gdbarch, args->lma));
return;
}
struct cleanup *verify_cleanups = make_cleanup (xfree, check);
if (target_read_memory (args->lma, check, bytes) != 0)
- error (_("Download verify read failed at 0x%s"),
- paddr (args->lma));
+ error (_("Download verify read failed at %s"),
+ paddress (target_gdbarch, args->lma));
if (memcmp (args->buffer, check, bytes) != 0)
- error (_("Download verify compare failed at 0x%s"),
- paddr (args->lma));
+ error (_("Download verify compare failed at %s"),
+ paddress (target_gdbarch, args->lma));
do_cleanups (verify_cleanups);
}
totals->data_count += bytes;
entry = bfd_get_start_address (loadfile_bfd);
ui_out_text (uiout, "Start address ");
- ui_out_field_fmt (uiout, "address", "0x%s", paddr_nz (entry));
+ ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch, entry));
ui_out_text (uiout, ", load size ");
ui_out_field_fmt (uiout, "load-size", "%lu", total_progress.data_count);
ui_out_text (uiout, "\n");
/* We were doing this in remote-mips.c, I suspect it is right
for other targets too. */
- write_pc (entry);
+ regcache_write_pc (get_current_regcache (), entry);
/* FIXME: are we supposed to call symbol_file_add or not? According
to a comment from remote-mips.c (where a call to symbol_file_add
static void
add_symbol_file_command (char *args, int from_tty)
{
+ struct gdbarch *gdbarch = get_current_arch ();
char *filename = NULL;
int flags = OBJF_USERLOADED;
char *arg;
entered on the command line. */
section_addrs->other[sec_num].name = sec;
section_addrs->other[sec_num].addr = addr;
- printf_unfiltered ("\t%s_addr = %s\n", sec, paddress (addr));
+ printf_unfiltered ("\t%s_addr = %s\n", sec,
+ paddress (gdbarch, addr));
sec_num++;
/* The object's sections are initialized when a
if (from_tty && (!query ("%s", "")))
error (_("Not confirmed."));
- symbol_file_add (filename, from_tty, section_addrs, 0, flags);
+ symbol_file_add (filename, from_tty ? SYMFILE_VERBOSE : 0,
+ section_addrs, flags);
/* Getting new symbols may change our opinion about what is
frameless. */
do_cleanups (my_cleanups);
}
\f
-static void
-add_shared_symbol_files_command (char *args, int from_tty)
-{
-#ifdef ADD_SHARED_SYMBOL_FILES
- ADD_SHARED_SYMBOL_FILES (args, from_tty);
-#else
- error (_("This command is not available in this configuration of GDB."));
-#endif
-}
-\f
+
/* Re-read symbols if a symbol-file has changed. */
void
reread_symbols (void)
objfile->obfd = bfd_openr (obfd_filename, gnutarget);
if (objfile->obfd == NULL)
error (_("Can't open %s to read symbols."), objfile->name);
+ else
+ objfile->obfd = gdb_bfd_ref (objfile->obfd);
/* bfd_openr sets cacheable to true, which is what we want. */
if (!bfd_check_format (objfile->obfd, bfd_object))
error (_("Can't read symbols from %s: %s."), objfile->name,
/* Nuke all the state that we will re-read. Much of the following
code which sets things to NULL really is necessary to tell
- other parts of GDB that there is nothing currently there. */
+ other parts of GDB that there is nothing currently there.
+
+ Try to keep the freeing order compatible with free_objfile. */
+
+ if (objfile->sf != NULL)
+ {
+ (*objfile->sf->sym_finish) (objfile);
+ }
+
+ clear_objfile_data (objfile);
/* FIXME: Do we have to free a whole linked list, or is this
enough? */
objfile->psymbol_cache = bcache_xmalloc ();
bcache_xfree (objfile->macro_cache);
objfile->macro_cache = bcache_xmalloc ();
+ bcache_xfree (objfile->filename_cache);
+ objfile->filename_cache = bcache_xmalloc ();
if (objfile->demangled_names_hash != NULL)
{
htab_delete (objfile->demangled_names_hash);
objfile->sections = NULL;
objfile->symtabs = NULL;
objfile->psymtabs = NULL;
+ objfile->psymtabs_addrmap = NULL;
objfile->free_psymtabs = NULL;
objfile->cp_namespace_symtab = NULL;
objfile->msymbols = NULL;
sizeof (objfile->msymbol_hash));
memset (&objfile->msymbol_demangled_hash, 0,
sizeof (objfile->msymbol_demangled_hash));
- clear_objfile_data (objfile);
- if (objfile->sf != NULL)
- {
- (*objfile->sf->sym_finish) (objfile);
- }
objfile->psymbol_cache = bcache_xmalloc ();
objfile->macro_cache = bcache_xmalloc ();
+ objfile->filename_cache = bcache_xmalloc ();
/* obstack_init also initializes the obstack so it is
empty. We could use obstack_specify_allocation but
gdb_obstack.h specifies the alloc/dealloc
zero is OK since dbxread.c also does what it needs to do if
objfile->global_psymbols.size is 0. */
(*objfile->sf->sym_read) (objfile, 0);
- if (!have_partial_symbols () && !have_full_symbols ())
+ if (!objfile_has_symbols (objfile))
{
wrap_here ("");
printf_unfiltered (_("(no debugging symbols found)\n"));
if (reread_one)
{
+ /* Notify objfiles that we've modified objfile sections. */
+ objfiles_changed ();
+
clear_symtab_users ();
/* At least one objfile has changed, so we can consider that
the executable we're debugging has changed too. */
observer_notify_executable_changed ();
}
-
}
objfile->separate_debug_objfile
= (symbol_file_add_with_addrs_or_offsets
(symfile_bfd_open (debug_file),
- info_verbose, /* from_tty: Don't override the default. */
+ info_verbose ? SYMFILE_VERBOSE : 0,
0, /* No addr table. */
objfile->section_offsets, objfile->num_sections,
- 0, /* Not mainline. See comments about this above. */
objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW
| OBJF_USERLOADED)));
objfile->separate_debug_objfile->separate_debug_objfile_backlink
symtab = (struct symtab *)
obstack_alloc (&objfile->objfile_obstack, sizeof (struct symtab));
memset (symtab, 0, sizeof (*symtab));
- symtab->filename = obsavestring (filename, strlen (filename),
- &objfile->objfile_obstack);
+ symtab->filename = (char *) bcache (filename, strlen (filename) + 1,
+ objfile->filename_cache);
symtab->fullname = NULL;
symtab->language = deduce_language_from_filename (filename);
- symtab->debugformat = obsavestring ("unknown", 7,
- &objfile->objfile_obstack);
+ symtab->debugformat = "unknown";
/* Hook it to the objfile it comes from */
}
struct partial_symtab *
-allocate_psymtab (char *filename, struct objfile *objfile)
+allocate_psymtab (const char *filename, struct objfile *objfile)
{
struct partial_symtab *psymtab;
sizeof (struct partial_symtab));
memset (psymtab, 0, sizeof (struct partial_symtab));
- psymtab->filename = obsavestring (filename, strlen (filename),
- &objfile->objfile_obstack);
+ psymtab->filename = (char *) bcache (filename, strlen (filename) + 1,
+ objfile->filename_cache);
psymtab->symtab = NULL;
/* Prepend it to the psymtab list for the objfile it belongs to.
clear_displays ();
breakpoint_re_set ();
- set_default_breakpoint (0, 0, 0, 0);
+ set_default_breakpoint (0, NULL, 0, 0, 0);
clear_pc_function_cache ();
observer_notify_new_objfile (NULL);
struct partial_symtab *
start_psymtab_common (struct objfile *objfile,
- struct section_offsets *section_offsets, char *filename,
+ struct section_offsets *section_offsets,
+ const char *filename,
CORE_ADDR textlow, struct partial_symbol **global_syms,
struct partial_symbol **static_syms)
{
different domain (or address) is possible and correct. */
static const struct partial_symbol *
-add_psymbol_to_bcache (char *name, int namelength, domain_enum domain,
+add_psymbol_to_bcache (char *name, int namelength, int copy_name,
+ domain_enum domain,
enum address_class class,
long val, /* Value as a long */
CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
enum language language, struct objfile *objfile,
int *added)
{
- char *buf = name;
/* psymbol is static so that there will be no uninitialized gaps in the
structure which might contain random data, causing cache misses in
bcache. */
static struct partial_symbol psymbol;
-
- if (name[namelength] != '\0')
- {
- buf = alloca (namelength + 1);
- /* Create local copy of the partial symbol */
- memcpy (buf, name, namelength);
- buf[namelength] = '\0';
- }
+
+ /* However, we must ensure that the entire 'value' field has been
+ zeroed before assigning to it, because an assignment may not
+ write the entire field. */
+ memset (&psymbol.ginfo.value, 0, sizeof (psymbol.ginfo.value));
/* val and coreaddr are mutually exclusive, one of them *will* be zero */
if (val != 0)
{
PSYMBOL_DOMAIN (&psymbol) = domain;
PSYMBOL_CLASS (&psymbol) = class;
- SYMBOL_SET_NAMES (&psymbol, buf, namelength, objfile);
+ SYMBOL_SET_NAMES (&psymbol, name, namelength, copy_name, objfile);
/* Stash the partial symbol away in the cache */
return bcache_full (&psymbol, sizeof (struct partial_symbol),
cache. */
const struct partial_symbol *
-add_psymbol_to_list (char *name, int namelength, domain_enum domain,
+add_psymbol_to_list (char *name, int namelength, int copy_name,
+ domain_enum domain,
enum address_class class,
struct psymbol_allocation_list *list,
long val, /* Value as a long */
int added;
/* Stash the partial symbol away in the cache */
- psym = add_psymbol_to_bcache (name, namelength, domain, class,
+ psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, class,
val, coreaddr, language, objfile, &added);
/* Do not duplicate global partial symbols. */
int
section_is_mapped (struct obj_section *osect)
{
+ struct gdbarch *gdbarch;
+
if (osect == 0 || !section_is_overlay (osect))
return 0;
case ovly_auto: /* overlay debugging automatic */
/* Unles there is a gdbarch_overlay_update function,
there's really nothing useful to do here (can't really go auto) */
- if (gdbarch_overlay_update_p (current_gdbarch))
+ gdbarch = get_objfile_arch (osect->objfile);
+ if (gdbarch_overlay_update_p (gdbarch))
{
if (overlay_cache_invalid)
{
overlay_cache_invalid = 0;
}
if (osect->ovly_mapped == -1)
- gdbarch_overlay_update (current_gdbarch, osect);
+ gdbarch_overlay_update (gdbarch, osect);
}
/* fall thru to manual case */
case ovly_on: /* overlay debugging manual */
ALL_OBJSECTIONS (objfile, osect)
if (section_is_mapped (osect))
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
const char *name;
bfd_vma lma, vma;
int size;
name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
printf_filtered ("Section %s, loaded at ", name);
- fputs_filtered (paddress (lma), gdb_stdout);
+ fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
puts_filtered (" - ");
- fputs_filtered (paddress (lma + size), gdb_stdout);
+ fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
printf_filtered (", mapped at ");
- fputs_filtered (paddress (vma), gdb_stdout);
+ fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
puts_filtered (" - ");
- fputs_filtered (paddress (vma + size), gdb_stdout);
+ fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
puts_filtered ("\n");
nmapped++;
static void
overlay_load_command (char *args, int from_tty)
{
- if (gdbarch_overlay_update_p (current_gdbarch))
- gdbarch_overlay_update (current_gdbarch, NULL);
+ struct gdbarch *gdbarch = get_current_arch ();
+
+ if (gdbarch_overlay_update_p (gdbarch))
+ gdbarch_overlay_update (gdbarch, NULL);
else
error (_("This target does not know how to read its overlay state."));
}
{
VMA, SIZE, LMA, MAPPED
};
-#define TARGET_LONG_BYTES (gdbarch_long_bit (current_gdbarch) \
- / TARGET_CHAR_BIT)
/* Throw away the cached copy of _ovly_table */
static void
}
#endif
-/* Read an array of ints from the target into a local buffer.
+/* Read an array of ints of size SIZE from the target into a local buffer.
Convert to host order. int LEN is number of ints */
static void
-read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, int len)
+read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr,
+ int len, int size, enum bfd_endian byte_order)
{
/* FIXME (alloca): Not safe if array is very large. */
- gdb_byte *buf = alloca (len * TARGET_LONG_BYTES);
+ gdb_byte *buf = alloca (len * size);
int i;
- read_memory (memaddr, buf, len * TARGET_LONG_BYTES);
+ read_memory (memaddr, buf, len * size);
for (i = 0; i < len; i++)
- myaddr[i] = extract_unsigned_integer (TARGET_LONG_BYTES * i + buf,
- TARGET_LONG_BYTES);
+ myaddr[i] = extract_unsigned_integer (size * i + buf, size, byte_order);
}
/* Find and grab a copy of the target _ovly_table
simple_read_overlay_table (void)
{
struct minimal_symbol *novlys_msym, *ovly_table_msym;
+ struct gdbarch *gdbarch;
+ int word_size;
+ enum bfd_endian byte_order;
simple_free_overlay_table ();
novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
return 0;
}
- cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym), 4);
+ gdbarch = get_objfile_arch (msymbol_objfile (ovly_table_msym));
+ word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
+ byte_order = gdbarch_byte_order (gdbarch);
+
+ cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym),
+ 4, byte_order);
cache_ovly_table
= (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
read_target_long_array (cache_ovly_table_base,
(unsigned int *) cache_ovly_table,
- cache_novlys * 4);
+ cache_novlys * 4, word_size, byte_order);
return 1; /* SUCCESS */
}
simple_read_overlay_region_table (void)
{
struct minimal_symbol *msym;
+ struct gdbarch *gdbarch;
+ int word_size;
+ enum bfd_endian byte_order;
simple_free_overlay_region_table ();
msym = lookup_minimal_symbol ("_novly_regions", NULL, NULL);
- if (msym != NULL)
- cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym), 4);
- else
+ if (msym == NULL)
return 0; /* failure */
+
+ gdbarch = get_objfile_arch (msymbol_objfile (msym));
+ word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
+ byte_order = gdbarch_byte_order (gdbarch);
+
+ cache_novly_regions = read_memory_integer (SYMBOL_VALUE_ADDRESS (msym),
+ 4, byte_order);
+
cache_ovly_region_table = (void *) xmalloc (cache_novly_regions * 12);
if (cache_ovly_region_table != NULL)
{
cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym);
read_target_long_array (cache_ovly_region_table_base,
(unsigned int *) cache_ovly_region_table,
- cache_novly_regions * 3);
+ cache_novly_regions * 3,
+ word_size, byte_order);
}
else
return 0; /* failure */
int i, size;
bfd *obfd = osect->objfile->obfd;
asection *bsect = osect->the_bfd_section;
+ struct gdbarch *gdbarch = get_objfile_arch (osect->objfile);
+ int word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
size = bfd_get_section_size (osect->the_bfd_section);
for (i = 0; i < cache_novlys; i++)
&& cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
/* && cache_ovly_table[i][SIZE] == size */ )
{
- read_target_long_array (cache_ovly_table_base + i * TARGET_LONG_BYTES,
- (unsigned int *) cache_ovly_table[i], 4);
+ read_target_long_array (cache_ovly_table_base + i * word_size,
+ (unsigned int *) cache_ovly_table[i],
+ 4, word_size, byte_order);
if (cache_ovly_table[i][VMA] == bfd_section_vma (obfd, bsect)
&& cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect)
/* && cache_ovly_table[i][SIZE] == size */ )
one affected platform is PowerPC GNU/Linux, although it depends on
the version of the linker in use). Also, ELF object files naturally
have unresolved relocations for their debug sections. We need to apply
- the relocations in order to get the locations of symbols correct. */
+ the relocations in order to get the locations of symbols correct.
+ Another example that may require relocation processing, is the
+ DWARF-2 .eh_frame section in .o files, although it isn't strictly a
+ debug section. */
bfd_byte *
symfile_relocate_debug_section (bfd *abfd, asection *sectp, bfd_byte *buf)
{
- /* We're only interested in debugging sections with relocation
+ /* We're only interested in sections with relocation
information. */
if ((sectp->flags & SEC_RELOC) == 0)
return NULL;
- if ((sectp->flags & SEC_DEBUGGING) == 0)
- return NULL;
/* We will handle section offsets properly elsewhere, so relocate as if
all sections begin at 0. */
&cmdlist);
set_cmd_completer (c, filename_completer);
- c = add_cmd ("add-shared-symbol-files", class_files,
- add_shared_symbol_files_command, _("\
-Load the symbols from shared objects in the dynamic linker's link map."),
- &cmdlist);
- c = add_alias_cmd ("assf", "add-shared-symbol-files", class_files, 1,
- &cmdlist);
-
c = add_cmd ("load", class_files, load_command, _("\
Dynamically load FILE into the running program, and record its symbols\n\
for access from GDB.\n\
add_setshow_optional_filename_cmd ("debug-file-directory", class_support,
&debug_file_directory, _("\
-Set the directory where separate debug symbols are searched for."), _("\
-Show the directory where separate debug symbols are searched for."), _("\
+Set the directories where separate debug symbols are searched for."), _("\
+Show the directories where separate debug symbols are searched for."), _("\
Separate debug symbols are first searched for in the same\n\
directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\
and lastly at the path of the directory of the binary with\n\
-the global debug-file directory prepended."),
+each global debug-file-directory component prepended."),
NULL,
show_debug_file_directory,
&setlist, &showlist);
-
- add_setshow_boolean_cmd ("symbol-loading", no_class,
- &print_symbol_loading, _("\
-Set printing of symbol loading messages."), _("\
-Show printing of symbol loading messages."), NULL,
- NULL,
- NULL,
- &setprintlist, &showprintlist);
}
projects / deliverable / binutils-gdb.git / blobdiff