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 ();
+
+ /* 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);
- symfile_objfile = NULL;
- if (from_tty)
- printf_unfiltered (_("No symbol file now.\n"));
+ gdb_assert (symfile_objfile == NULL);
+ if (from_tty)
+ printf_unfiltered (_("No symbol file now.\n"));
}
struct build_id
}
static int
-separate_debug_file_exists (const char *name, unsigned long crc)
+separate_debug_file_exists (const char *name, unsigned long crc,
+ const char *parent_name)
{
unsigned long file_crc = 0;
bfd *abfd;
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_name);
+ return 0;
+ }
+
+ return 1;
}
char *debug_file_directory = NULL;
basename = get_debug_link_info (objfile, &crc32);
if (basename == NULL)
+ /* There's no separate debug info, hence there's no way we could
+ load it => no warning. */
return NULL;
dir = xstrdup (objfile->name);
gdb_assert (i >= 0 && IS_DIR_SEPARATOR (dir[i]));
dir[i+1] = '\0';
+ /* 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 = alloca (strlen (debug_file_directory) + 1
- + strlen (dir)
+ + i
+ strlen (DEBUG_SUBDIRECTORY)
+ strlen ("/")
+ strlen (basename)
strcpy (debugfile, dir);
strcat (debugfile, basename);
- if (separate_debug_file_exists (debugfile, crc32))
+ if (separate_debug_file_exists (debugfile, crc32, objfile->name))
{
xfree (basename);
xfree (dir);
+ xfree (canon_name);
return xstrdup (debugfile);
}
strcat (debugfile, "/");
strcat (debugfile, basename);
- if (separate_debug_file_exists (debugfile, crc32))
+ if (separate_debug_file_exists (debugfile, crc32, objfile->name))
{
xfree (basename);
xfree (dir);
+ xfree (canon_name);
return xstrdup (debugfile);
}
strcat (debugfile, dir);
strcat (debugfile, basename);
- if (separate_debug_file_exists (debugfile, crc32))
+ if (separate_debug_file_exists (debugfile, crc32, objfile->name))
{
xfree (basename);
xfree (dir);
+ xfree (canon_name);
return xstrdup (debugfile);
}
/* 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)]))
strcat (debugfile, "/");
strcat (debugfile, basename);
- if (separate_debug_file_exists (debugfile, crc32))
+ if (separate_debug_file_exists (debugfile, crc32, objfile->name))
{
xfree (canon_name);
xfree (basename);
/* 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->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 ();
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
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);
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\
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