/* Generic symbol file reading for the GNU debugger, GDB.
Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "bfdlink.h"
#include "exec.h"
#include "parser-defs.h"
#include "varobj.h"
+#include "elf-bfd.h"
+#include "solib.h"
+#include "remote.h"
#include <sys/types.h>
#include <fcntl.h>
static void simple_free_overlay_region_table (void);
#endif
-static void set_initial_language (void);
-
static void load_command (char *, int);
static void symbol_file_add_main_1 (char *args, int from_tty, int flags);
int get_section_index (struct objfile *, char *);
-static void find_sym_fns (struct objfile *);
+static struct sym_fns *find_sym_fns (bfd *);
static void decrement_reading_symtab (void *);
static void overlay_invalidate_all (void);
-static int overlay_is_mapped (struct obj_section *);
-
void list_overlays_command (char *, int);
void map_overlay_command (char *, int);
static void init_filename_language_table (void);
+static void symfile_find_segment_sections (struct objfile *objfile);
+
void _initialize_symfile (void);
/* List of all available sym_fns. On gdb startup, each object file reader
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
/* This is where things get really weird... We MUST have valid
indices for the various sect_index_* members or gdb will abort.
So if for example, there is no ".text" section, we have to
- accomodate that. Except when explicitly adding symbol files at
- some address, section_offsets contains nothing but zeros, so it
- doesn't matter which slot in section_offsets the individual
- sect_index_* members index into. So if they are all zero, it is
- safe to just point all the currently uninitialized indices to the
- first slot. */
+ accomodate that. First, check for a file with the standard
+ one or two segments. */
+
+ symfile_find_segment_sections (objfile);
+
+ /* Except when explicitly adding symbol files at some address,
+ section_offsets contains nothing but zeros, so it doesn't matter
+ which slot in section_offsets the individual sect_index_* members
+ index into. So if they are all zero, it is safe to just point
+ all the currently uninitialized indices to the first slot. But
+ beware: if this is the main executable, it may be relocated
+ later, e.g. by the remote qOffsets packet, and then this will
+ be wrong! That's why we try segments first. */
for (i = 0; i < objfile->num_sections; i++)
{
offsets[sect->index] = start_addr;
arg->lowest = start_addr + bfd_get_section_size (sect);
-
- exec_set_section_address (bfd_get_filename (abfd), sect->index, start_addr);
}
/* Parse the user's idea of an offset for dynamic linking, into our idea
continue;
bfd_set_section_vma (abfd, cur_sec, offsets[cur_sec->index]);
+ exec_set_section_address (bfd_get_filename (abfd), cur_sec->index,
+ offsets[cur_sec->index]);
offsets[cur_sec->index] = 0;
}
}
}
+/* Divide the file into segments, which are individual relocatable units.
+ This is the default version of the sym_fns.sym_segments function for
+ symbol readers that do not have an explicit representation of segments.
+ It assumes that object files do not have segments, and fully linked
+ files have a single segment. */
+
+struct symfile_segment_data *
+default_symfile_segments (bfd *abfd)
+{
+ int num_sections, i;
+ asection *sect;
+ struct symfile_segment_data *data;
+ CORE_ADDR low, high;
+
+ /* Relocatable files contain enough information to position each
+ loadable section independently; they should not be relocated
+ in segments. */
+ if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) == 0)
+ return NULL;
+
+ /* Make sure there is at least one loadable section in the file. */
+ for (sect = abfd->sections; sect != NULL; sect = sect->next)
+ {
+ if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
+ continue;
+
+ break;
+ }
+ if (sect == NULL)
+ return NULL;
+
+ low = bfd_get_section_vma (abfd, sect);
+ high = low + bfd_get_section_size (sect);
+
+ data = XZALLOC (struct symfile_segment_data);
+ data->num_segments = 1;
+ data->segment_bases = XCALLOC (1, CORE_ADDR);
+ data->segment_sizes = XCALLOC (1, CORE_ADDR);
+
+ num_sections = bfd_count_sections (abfd);
+ data->segment_info = XCALLOC (num_sections, int);
+
+ for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
+ {
+ CORE_ADDR vma;
+
+ if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
+ continue;
+
+ vma = bfd_get_section_vma (abfd, sect);
+ if (vma < low)
+ low = vma;
+ if (vma + bfd_get_section_size (sect) > high)
+ high = vma + bfd_get_section_size (sect);
+
+ data->segment_info[i] = 1;
+ }
+
+ data->segment_bases[0] = low;
+ data->segment_sizes[0] = high - low;
+
+ return data;
+}
+
/* Process a symbol file, as either the main file or as a dynamically
loaded file.
gdb_assert (! (addrs && offsets));
init_entry_point_info (objfile);
- find_sym_fns (objfile);
+ objfile->sf = find_sym_fns (objfile->obfd);
if (objfile->sf == NULL)
return; /* No symbols. */
bfd_map_over_sections (objfile->obfd, find_lowest_section,
&lower_sect);
if (lower_sect == NULL)
- warning (_("no loadable sections found in added symbol-file %s"),
- objfile->name);
- else
- if ((bfd_get_section_flags (objfile->obfd, lower_sect) & SEC_CODE) == 0)
- warning (_("Lowest section in %s is %s at %s"),
- objfile->name,
- bfd_section_name (objfile->obfd, lower_sect),
- paddr (bfd_section_vma (objfile->obfd, lower_sect)));
- if (lower_sect != NULL)
- lower_offset = bfd_section_vma (objfile->obfd, lower_sect);
+ {
+ warning (_("no loadable sections found in added symbol-file %s"),
+ objfile->name);
+ lower_offset = 0;
+ }
else
- lower_offset = 0;
+ lower_offset = bfd_section_vma (objfile->obfd, lower_sect);
/* Calculate offsets for the loadable sections.
FIXME! Sections must be in order of increasing loadable section
init_objfile_sect_indices (objfile);
}
-#ifndef DEPRECATED_IBM6000_TARGET
- /* This is a SVR4/SunOS specific hack, I think. In any event, it
- screws RS/6000. sym_offsets should be doing this sort of thing,
- because it knows the mapping between bfd sections and
- section_offsets. */
- /* This is a hack. As far as I can tell, section offsets are not
- target dependent. They are all set to addr with a couple of
- exceptions. The exceptions are sysvr4 shared libraries, whose
- offsets are kept in solib structures anyway and rs6000 xcoff
- which handles shared libraries in a completely unique way.
-
- Section offsets are built similarly, except that they are built
- by adding addr in all cases because there is no clear mapping
- from section_offsets into actual sections. Note that solib.c
- has a different algorithm for finding section offsets.
-
- These should probably all be collapsed into some target
- independent form of shared library support. FIXME. */
-
- if (addrs)
- {
- struct obj_section *s;
-
- /* Map section offsets in "addr" back to the object's
- sections by comparing the section names with bfd's
- section names. Then adjust the section address by
- the offset. */ /* for gdb/13815 */
-
- ALL_OBJFILE_OSECTIONS (objfile, s)
- {
- CORE_ADDR s_addr = 0;
- int i;
-
- for (i = 0;
- !s_addr && i < addrs->num_sections && addrs->other[i].name;
- i++)
- if (strcmp (bfd_section_name (s->objfile->obfd,
- s->the_bfd_section),
- addrs->other[i].name) == 0)
- s_addr = addrs->other[i].addr; /* end added for gdb/13815 */
-
- s->addr -= s->offset;
- s->addr += s_addr;
- s->endaddr -= s->offset;
- s->endaddr += s_addr;
- s->offset += s_addr;
- }
- }
-#endif /* not DEPRECATED_IBM6000_TARGET */
-
(*objfile->sf->sym_read) (objfile, mainline);
- /* Don't allow char * to have a typename (else would get caddr_t).
- Ditto void *. FIXME: Check whether this is now done by all the
- symbol readers themselves (many of them now do), and if so remove
- it from here. */
-
- TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
- TYPE_NAME (lookup_pointer_type (builtin_type_void)) = 0;
-
- /* Mark the objfile has having had initial symbol read attempted. Note
- that this does not mean we found any symbols... */
-
- objfile->flags |= OBJF_SYMS;
-
/* Discard cleanups as symbol reading was successful. */
discard_cleanups (old_chain);
+ xfree (local_addr);
}
/* Perform required actions after either reading in the initial
{
struct objfile *objfile;
struct partial_symtab *psymtab;
- char *debugfile;
+ char *debugfile = NULL;
struct section_addr_info *orig_addrs = NULL;
struct cleanup *my_cleanups;
const char *name = bfd_get_filename (abfd);
deprecated_pre_add_symbol_hook (name);
else
{
- printf_unfiltered (_("Reading symbols from %s..."), name);
- wrap_here ("");
- gdb_flush (gdb_stdout);
+ if (print_symbol_loading)
+ {
+ printf_unfiltered (_("Reading symbols from %s..."), name);
+ wrap_here ("");
+ gdb_flush (gdb_stdout);
+ }
}
}
syms_from_objfile (objfile, addrs, offsets, num_offsets,
if ((flags & OBJF_READNOW) || readnow_symbol_files)
{
- if (from_tty || info_verbose)
+ if ((from_tty || info_verbose) && print_symbol_loading)
{
printf_unfiltered (_("expanding to full symbols..."));
wrap_here ("");
}
}
- debugfile = find_separate_debug_file (objfile);
+ /* If the file has its own symbol tables it has no separate debug info.
+ `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to SYMTABS/PSYMTABS.
+ `.gnu_debuglink' may no longer be present with `.note.gnu.build-id'. */
+ if (objfile->psymtabs == NULL)
+ debugfile = find_separate_debug_file (objfile);
if (debugfile)
{
if (addrs != NULL)
xfree (debugfile);
}
- if (!have_partial_symbols () && !have_full_symbols ())
+ if (!have_partial_symbols () && !have_full_symbols ()
+ && print_symbol_loading)
{
wrap_here ("");
- printf_filtered (_("(no debugging symbols found)"));
+ printf_unfiltered (_("(no debugging symbols found)"));
if (from_tty || info_verbose)
- printf_filtered ("...");
+ printf_unfiltered ("...");
else
- printf_filtered ("\n");
+ printf_unfiltered ("\n");
wrap_here ("");
}
deprecated_post_add_symbol_hook ();
else
{
- printf_unfiltered (_("done.\n"));
+ if (print_symbol_loading)
+ printf_unfiltered (_("done.\n"));
}
}
storage has just been released, we'd better wipe the solib
descriptors as well.
*/
-#if defined(SOLIB_RESTART)
- SOLIB_RESTART ();
-#endif
+ no_shared_libraries (NULL, from_tty);
symfile_objfile = NULL;
if (from_tty)
printf_unfiltered (_("No symbol file now.\n"));
}
+struct build_id
+ {
+ size_t size;
+ gdb_byte data[1];
+ };
+
+/* Locate NT_GNU_BUILD_ID from ABFD and return its content. */
+
+static struct build_id *
+build_id_bfd_get (bfd *abfd)
+{
+ struct build_id *retval;
+
+ if (!bfd_check_format (abfd, bfd_object)
+ || bfd_get_flavour (abfd) != bfd_target_elf_flavour
+ || elf_tdata (abfd)->build_id == NULL)
+ return NULL;
+
+ retval = xmalloc (sizeof *retval - 1 + elf_tdata (abfd)->build_id_size);
+ retval->size = elf_tdata (abfd)->build_id_size;
+ memcpy (retval->data, elf_tdata (abfd)->build_id, retval->size);
+
+ return retval;
+}
+
+/* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */
+
+static int
+build_id_verify (const char *filename, struct build_id *check)
+{
+ bfd *abfd;
+ struct build_id *found = NULL;
+ int retval = 0;
+
+ /* We expect to be silent on the non-existing files. */
+ if (remote_filename_p (filename))
+ abfd = remote_bfd_open (filename, gnutarget);
+ else
+ abfd = bfd_openr (filename, gnutarget);
+ if (abfd == NULL)
+ return 0;
+
+ found = build_id_bfd_get (abfd);
+
+ if (found == NULL)
+ warning (_("File \"%s\" has no build-id, file skipped"), filename);
+ else if (found->size != check->size
+ || memcmp (found->data, check->data, found->size) != 0)
+ warning (_("File \"%s\" has a different build-id, file skipped"), filename);
+ else
+ retval = 1;
+
+ if (!bfd_close (abfd))
+ warning (_("cannot close \"%s\": %s"), filename,
+ bfd_errmsg (bfd_get_error ()));
+
+ xfree (found);
+
+ return retval;
+}
+
+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;
+
+ /* 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))
+ {
+ xfree (retval);
+ retval = NULL;
+ }
+
+ return retval;
+}
+
static char *
get_debug_link_info (struct objfile *objfile, unsigned long *crc32_out)
{
separate_debug_file_exists (const char *name, unsigned long crc)
{
unsigned long file_crc = 0;
- int fd;
+ bfd *abfd;
gdb_byte buffer[8*1024];
int count;
- fd = open (name, O_RDONLY | O_BINARY);
- if (fd < 0)
+ if (remote_filename_p (name))
+ abfd = remote_bfd_open (name, gnutarget);
+ else
+ abfd = bfd_openr (name, gnutarget);
+
+ if (!abfd)
return 0;
- while ((count = read (fd, buffer, sizeof (buffer))) > 0)
+ while ((count = bfd_bread (buffer, sizeof (buffer), abfd)) > 0)
file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
- close (fd);
+ bfd_close (abfd);
return crc == file_crc;
}
bfd_size_type debuglink_size;
unsigned long crc32;
int i;
+ struct build_id *build_id;
+
+ build_id = build_id_bfd_get (objfile->obfd);
+ if (build_id != NULL)
+ {
+ char *build_id_name;
+
+ build_id_name = build_id_to_debug_filename (build_id);
+ xfree (build_id);
+ /* Prevent looping on a stripped .debug file. */
+ if (build_id_name != NULL && strcmp (build_id_name, objfile->name) == 0)
+ {
+ warning (_("\"%s\": separate debug info file has no debug info"),
+ build_id_name);
+ xfree (build_id_name);
+ }
+ else if (build_id_name != NULL)
+ return build_id_name;
+ }
basename = get_debug_link_info (objfile, &crc32);
}
else
{
- char **argv = buildargv (args);
+ char **argv = gdb_buildargv (args);
int flags = OBJF_USERLOADED;
struct cleanup *cleanups;
char *name = NULL;
- if (argv == NULL)
- nomem (0);
-
cleanups = make_cleanup_freeargv (argv);
while (*argv != NULL)
{
stabs we find, but we can't do that until later when we read in
full symbols. */
-static void
+void
set_initial_language (void)
{
struct partial_symtab *pst;
int desc;
char *absolute_name;
+ if (remote_filename_p (name))
+ {
+ name = xstrdup (name);
+ sym_bfd = remote_bfd_open (name, gnutarget);
+ if (!sym_bfd)
+ {
+ make_cleanup (xfree, name);
+ error (_("`%s': can't open to read symbols: %s."), name,
+ bfd_errmsg (bfd_get_error ()));
+ }
+
+ if (!bfd_check_format (sym_bfd, bfd_object))
+ {
+ bfd_close (sym_bfd);
+ make_cleanup (xfree, name);
+ error (_("`%s': can't read symbols: %s."), name,
+ bfd_errmsg (bfd_get_error ()));
+ }
+
+ return sym_bfd;
+ }
+
name = tilde_expand (name); /* Returns 1st new malloc'd copy. */
/* Look down path for it, allocate 2nd new malloc'd copy. */
{
close (desc);
make_cleanup (xfree, name);
- error (_("\"%s\": can't open to read symbols: %s."), name,
+ error (_("`%s': can't open to read symbols: %s."), name,
bfd_errmsg (bfd_get_error ()));
}
bfd_set_cacheable (sym_bfd, 1);
with the bfd). */
bfd_close (sym_bfd); /* This also closes desc. */
make_cleanup (xfree, name);
- error (_("\"%s\": can't read symbols: %s."), name,
+ error (_("`%s': can't read symbols: %s."), name,
bfd_errmsg (bfd_get_error ()));
}
struct sym_fns in the objfile structure, that contains cached
information about the symbol file. */
-static void
-find_sym_fns (struct objfile *objfile)
+static struct sym_fns *
+find_sym_fns (bfd *abfd)
{
struct sym_fns *sf;
- enum bfd_flavour our_flavour = bfd_get_flavour (objfile->obfd);
- char *our_target = bfd_get_target (objfile->obfd);
+ enum bfd_flavour our_flavour = bfd_get_flavour (abfd);
if (our_flavour == bfd_target_srec_flavour
|| our_flavour == bfd_target_ihex_flavour
|| our_flavour == bfd_target_tekhex_flavour)
- return; /* No symbols. */
+ return NULL; /* No symbols. */
for (sf = symtab_fns; sf != NULL; sf = sf->next)
- {
- if (our_flavour == sf->sym_flavour)
- {
- objfile->sf = sf;
- return;
- }
- }
+ if (our_flavour == sf->sym_flavour)
+ return sf;
error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
- bfd_get_target (objfile->obfd));
+ bfd_get_target (abfd));
}
\f
static void
load_command (char *arg, int from_tty)
{
+ /* The user might be reloading because the binary has changed. Take
+ this opportunity to check. */
+ reopen_exec_file ();
+ reread_symbols ();
+
if (arg == NULL)
{
char *parg;
}
}
- /* The user might be reloading because the binary has changed. Take
- this opportunity to check. */
- reopen_exec_file ();
- reread_symbols ();
-
target_load (arg, from_tty);
/* After re-loading the executable, we don't really know which
make_cleanup (clear_memory_write_data, &cbdata.requests);
- argv = buildargv (args);
-
- if (argv == NULL)
- nomem(0);
+ if (args == NULL)
+ error_no_arg (_("file to load"));
+ argv = gdb_buildargv (args);
make_cleanup_freeargv (argv);
filename = tilde_expand (argv[0]);
const struct timeval *start_time,
const struct timeval *end_time)
{
- unsigned long time_count;
+ ULONGEST time_count;
/* Compute the elapsed time in milliseconds, as a tradeoff between
accuracy and overflow. */
ui_out_text (uiout, "Transfer rate: ");
if (time_count > 0)
{
- ui_out_field_fmt (uiout, "transfer-rate", "%lu",
- 1000 * (data_count * 8) / time_count);
- ui_out_text (uiout, " bits/sec");
+ unsigned long rate = ((ULONGEST) data_count * 1000) / time_count;
+
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate * 8);
+ ui_out_text (uiout, " bits/sec");
+ }
+ else if (rate < 1024)
+ {
+ ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate);
+ ui_out_text (uiout, " bytes/sec");
+ }
+ else
+ {
+ ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate / 1024);
+ ui_out_text (uiout, " KB/sec");
+ }
}
else
{
if (args == NULL)
error (_("add-symbol-file takes a file name and an address"));
- argv = buildargv (args);
+ argv = gdb_buildargv (args);
make_cleanup_freeargv (argv);
- if (argv == NULL)
- nomem (0);
-
for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt])
{
/* Process the argument. */
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, hex_string ((unsigned long)addr));
+ printf_unfiltered ("\t%s_addr = %s\n", sec, paddress (addr));
sec_num++;
/* The object's sections are initialized when a
/* We need to do this whenever any symbols go away. */
make_cleanup (clear_symtab_users_cleanup, 0 /*ignore*/);
+ if (exec_bfd != NULL && strcmp (bfd_get_filename (objfile->obfd),
+ bfd_get_filename (exec_bfd)) == 0)
+ {
+ /* Reload EXEC_BFD without asking anything. */
+
+ exec_file_attach (bfd_get_filename (objfile->obfd), 0);
+ }
+
/* Clean up any state BFD has sitting around. We don't need
to close the descriptor but BFD lacks a way of closing the
BFD without closing the descriptor. */
if (!bfd_close (objfile->obfd))
error (_("Can't close BFD for %s: %s"), objfile->name,
bfd_errmsg (bfd_get_error ()));
- objfile->obfd = bfd_openr (obfd_filename, gnutarget);
+ if (remote_filename_p (obfd_filename))
+ objfile->obfd = remote_bfd_open (obfd_filename, gnutarget);
+ else
+ objfile->obfd = bfd_openr (obfd_filename, gnutarget);
if (objfile->obfd == NULL)
error (_("Can't open %s to read symbols."), objfile->name);
/* bfd_openr sets cacheable to true, which is what we want. */
sizeof (objfile->msymbol_hash));
memset (&objfile->msymbol_demangled_hash, 0,
sizeof (objfile->msymbol_demangled_hash));
- objfile->fundamental_types = NULL;
clear_objfile_data (objfile);
if (objfile->sf != NULL)
{
(*objfile->sf->sym_finish) (objfile);
}
- /* We never make this a mapped file. */
- objfile->md = NULL;
objfile->psymbol_cache = bcache_xmalloc ();
objfile->macro_cache = bcache_xmalloc ();
/* obstack_init also initializes the obstack so it is
printf_unfiltered (_("(no debugging symbols found)\n"));
wrap_here ("");
}
- objfile->flags |= OBJF_SYMS;
/* We're done reading the symbol file; finish off complaints. */
clear_complaints (&symfile_complaints, 0, 1);
objfile->mtime = new_modtime;
reread_one = 1;
reread_separate_symbols (objfile);
+ init_entry_point_info (objfile);
}
}
}
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 (NULL);
+ observer_notify_executable_changed ();
}
}
objfile->separate_debug_objfile->separate_debug_objfile_backlink
= objfile;
}
+ if (debug_file)
+ xfree (debug_file);
}
add_filename_language (".f", language_fortran);
add_filename_language (".F", language_fortran);
add_filename_language (".s", language_asm);
+ add_filename_language (".sx", language_asm);
add_filename_language (".S", language_asm);
add_filename_language (".pas", language_pascal);
add_filename_language (".p", language_pascal);
return (psymtab);
}
\f
-/* Add a symbol with a long value to a psymtab.
- Since one arg is a struct, we pass in a ptr and deref it (sigh).
- Return the partial symbol that has been added. */
-
-/* NOTE: carlton/2003-09-11: The reason why we return the partial
- symbol is so that callers can get access to the symbol's demangled
- name, which they don't have any cheap way to determine otherwise.
- (Currenly, dwarf2read.c is the only file who uses that information,
- though it's possible that other readers might in the future.)
- Elena wasn't thrilled about that, and I don't blame her, but we
- couldn't come up with a better way to get that information. If
- it's needed in other situations, we could consider breaking up
- SYMBOL_SET_NAMES to provide access to the demangled name lookup
- cache. */
-
-const struct partial_symbol *
-add_psymbol_to_list (char *name, int namelength, domain_enum domain,
- enum address_class class,
- struct psymbol_allocation_list *list, long val, /* Value as a long */
- CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
- enum language language, struct objfile *objfile)
+/* Helper function, initialises partial symbol structure and stashes
+ it into objfile's bcache. Note that our caching mechanism will
+ use all fields of struct partial_symbol to determine hash value of the
+ structure. In other words, having two symbols with the same name but
+ different domain (or address) is possible and correct. */
+
+static const struct partial_symbol *
+add_psymbol_to_bcache (char *name, int namelength, 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)
{
- struct partial_symbol *psym;
- char *buf = alloca (namelength + 1);
+ 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;
-
- /* Create local copy of the partial symbol */
- memcpy (buf, name, namelength);
- buf[namelength] = '\0';
+
+ if (name[namelength] != '\0')
+ {
+ buf = alloca (namelength + 1);
+ /* Create local copy of the partial symbol */
+ memcpy (buf, name, namelength);
+ buf[namelength] = '\0';
+ }
/* val and coreaddr are mutually exclusive, one of them *will* be zero */
if (val != 0)
{
SYMBOL_SET_NAMES (&psymbol, buf, namelength, objfile);
/* Stash the partial symbol away in the cache */
- psym = deprecated_bcache (&psymbol, sizeof (struct partial_symbol),
- objfile->psymbol_cache);
+ return bcache_full (&psymbol, sizeof (struct partial_symbol),
+ objfile->psymbol_cache, added);
+}
- /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
+/* Helper function, adds partial symbol to the given partial symbol
+ list. */
+
+static void
+append_psymbol_to_list (struct psymbol_allocation_list *list,
+ const struct partial_symbol *psym,
+ struct objfile *objfile)
+{
if (list->next >= list->list + list->size)
- {
- extend_psymbol_list (list, objfile);
- }
- *list->next++ = psym;
+ extend_psymbol_list (list, objfile);
+ *list->next++ = (struct partial_symbol *) psym;
OBJSTAT (objfile, n_psyms++);
+}
+/* Add a symbol with a long value to a psymtab.
+ Since one arg is a struct, we pass in a ptr and deref it (sigh).
+ Return the partial symbol that has been added. */
+
+/* NOTE: carlton/2003-09-11: The reason why we return the partial
+ symbol is so that callers can get access to the symbol's demangled
+ name, which they don't have any cheap way to determine otherwise.
+ (Currenly, dwarf2read.c is the only file who uses that information,
+ though it's possible that other readers might in the future.)
+ Elena wasn't thrilled about that, and I don't blame her, but we
+ couldn't come up with a better way to get that information. If
+ it's needed in other situations, we could consider breaking up
+ SYMBOL_SET_NAMES to provide access to the demangled name lookup
+ cache. */
+
+const struct partial_symbol *
+add_psymbol_to_list (char *name, int namelength, domain_enum domain,
+ enum address_class class,
+ struct psymbol_allocation_list *list,
+ long val, /* Value as a long */
+ CORE_ADDR coreaddr, /* Value as a CORE_ADDR */
+ enum language language, struct objfile *objfile)
+{
+ const struct partial_symbol *psym;
+
+ int added;
+
+ /* Stash the partial symbol away in the cache */
+ psym = add_psymbol_to_bcache (name, namelength, domain, class,
+ val, coreaddr, language, objfile, &added);
+
+ /* Do not duplicate global partial symbols. */
+ if (list == &objfile->global_psymbols
+ && !added)
+ return psym;
+
+ /* Save pointer to partial symbol in psymtab, growing symtab if needed. */
+ append_psymbol_to_list (list, psym, objfile);
return psym;
}
section, return that section.
find_pc_overlay(pc): find any overlay section that contains
the pc, either in its VMA or its LMA
- overlay_is_mapped(sect): true if overlay is marked as mapped
+ section_is_mapped(sect): true if overlay is marked as mapped
section_is_overlay(sect): true if section's VMA != LMA
pc_in_mapped_range(pc,sec): true if pc belongs to section's VMA
pc_in_unmapped_range(...): true if pc belongs to section's LMA
SECTION is loaded at an address different from where it will "run". */
int
-section_is_overlay (asection *section)
+section_is_overlay (struct obj_section *section)
{
- /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
-
- if (overlay_debugging)
- if (section && section->lma != 0 &&
- section->vma != section->lma)
- return 1;
+ if (overlay_debugging && section)
+ {
+ bfd *abfd = section->objfile->obfd;
+ asection *bfd_section = section->the_bfd_section;
+
+ if (bfd_section_lma (abfd, bfd_section) != 0
+ && bfd_section_lma (abfd, bfd_section)
+ != bfd_section_vma (abfd, bfd_section))
+ return 1;
+ }
return 0;
}
struct obj_section *sect;
ALL_OBJSECTIONS (objfile, sect)
- if (section_is_overlay (sect->the_bfd_section))
- sect->ovly_mapped = -1;
+ if (section_is_overlay (sect))
+ sect->ovly_mapped = -1;
}
-/* Function: overlay_is_mapped (SECTION)
+/* Function: section_is_mapped (SECTION)
Returns true if section is an overlay, and is currently mapped.
- Private: public access is thru function section_is_mapped.
Access to the ovly_mapped flag is restricted to this function, so
that we can do automatic update. If the global flag
overlay_invalidate_all. If the mapped state of the particular
section is stale, then call TARGET_OVERLAY_UPDATE to refresh it. */
-static int
-overlay_is_mapped (struct obj_section *osect)
+int
+section_is_mapped (struct obj_section *osect)
{
- if (osect == 0 || !section_is_overlay (osect->the_bfd_section))
+ if (osect == 0 || !section_is_overlay (osect))
return 0;
switch (overlay_debugging)
}
}
-/* Function: section_is_mapped
- Returns true if section is an overlay, and is currently mapped. */
-
-int
-section_is_mapped (asection *section)
-{
- struct objfile *objfile;
- struct obj_section *osect;
-
- if (overlay_debugging)
- if (section && section_is_overlay (section))
- ALL_OBJSECTIONS (objfile, osect)
- if (osect->the_bfd_section == section)
- return overlay_is_mapped (osect);
-
- return 0;
-}
-
/* Function: pc_in_unmapped_range
If PC falls into the lma range of SECTION, return true, else false. */
CORE_ADDR
-pc_in_unmapped_range (CORE_ADDR pc, asection *section)
+pc_in_unmapped_range (CORE_ADDR pc, struct obj_section *section)
{
- /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
+ if (section_is_overlay (section))
+ {
+ bfd *abfd = section->objfile->obfd;
+ asection *bfd_section = section->the_bfd_section;
- int size;
+ /* We assume the LMA is relocated by the same offset as the VMA. */
+ bfd_vma size = bfd_get_section_size (bfd_section);
+ CORE_ADDR offset = obj_section_offset (section);
+
+ if (bfd_get_section_lma (abfd, bfd_section) + offset <= pc
+ && pc < bfd_get_section_lma (abfd, bfd_section) + offset + size)
+ return 1;
+ }
- if (overlay_debugging)
- if (section && section_is_overlay (section))
- {
- size = bfd_get_section_size (section);
- if (section->lma <= pc && pc < section->lma + size)
- return 1;
- }
return 0;
}
If PC falls into the vma range of SECTION, return true, else false. */
CORE_ADDR
-pc_in_mapped_range (CORE_ADDR pc, asection *section)
+pc_in_mapped_range (CORE_ADDR pc, struct obj_section *section)
{
- /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
-
- int size;
+ if (section_is_overlay (section))
+ {
+ if (obj_section_addr (section) <= pc
+ && pc < obj_section_endaddr (section))
+ return 1;
+ }
- if (overlay_debugging)
- if (section && section_is_overlay (section))
- {
- size = bfd_get_section_size (section);
- if (section->vma <= pc && pc < section->vma + size)
- return 1;
- }
return 0;
}
/* Return true if the mapped ranges of sections A and B overlap, false
otherwise. */
static int
-sections_overlap (asection *a, asection *b)
+sections_overlap (struct obj_section *a, struct obj_section *b)
{
- /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
-
- CORE_ADDR a_start = a->vma;
- CORE_ADDR a_end = a->vma + bfd_get_section_size (a);
- CORE_ADDR b_start = b->vma;
- CORE_ADDR b_end = b->vma + bfd_get_section_size (b);
+ CORE_ADDR a_start = obj_section_addr (a);
+ CORE_ADDR a_end = obj_section_endaddr (a);
+ CORE_ADDR b_start = obj_section_addr (b);
+ CORE_ADDR b_end = obj_section_endaddr (b);
return (a_start < b_end && b_start < a_end);
}
May be the same as PC. */
CORE_ADDR
-overlay_unmapped_address (CORE_ADDR pc, asection *section)
+overlay_unmapped_address (CORE_ADDR pc, struct obj_section *section)
{
- /* FIXME: need bfd *, so we can use bfd_section_lma methods. */
+ if (section_is_overlay (section) && pc_in_mapped_range (pc, section))
+ {
+ bfd *abfd = section->objfile->obfd;
+ asection *bfd_section = section->the_bfd_section;
- if (overlay_debugging)
- if (section && section_is_overlay (section) &&
- pc_in_mapped_range (pc, section))
- return pc + section->lma - section->vma;
+ return pc + bfd_section_lma (abfd, bfd_section)
+ - bfd_section_vma (abfd, bfd_section);
+ }
return pc;
}
May be the same as PC. */
CORE_ADDR
-overlay_mapped_address (CORE_ADDR pc, asection *section)
+overlay_mapped_address (CORE_ADDR pc, struct obj_section *section)
{
- /* FIXME: need bfd *, so we can use bfd_section_vma methods. */
+ if (section_is_overlay (section) && pc_in_unmapped_range (pc, section))
+ {
+ bfd *abfd = section->objfile->obfd;
+ asection *bfd_section = section->the_bfd_section;
- if (overlay_debugging)
- if (section && section_is_overlay (section) &&
- pc_in_unmapped_range (pc, section))
- return pc + section->vma - section->lma;
+ return pc + bfd_section_vma (abfd, bfd_section)
+ - bfd_section_lma (abfd, bfd_section);
+ }
return pc;
}
depending on whether the section is mapped or not. */
CORE_ADDR
-symbol_overlayed_address (CORE_ADDR address, asection *section)
+symbol_overlayed_address (CORE_ADDR address, struct obj_section *section)
{
if (overlay_debugging)
{
Else if PC matches an unmapped section's VMA, return that section.
Else if PC matches an unmapped section's LMA, return that section. */
-asection *
+struct obj_section *
find_pc_overlay (CORE_ADDR pc)
{
struct objfile *objfile;
if (overlay_debugging)
ALL_OBJSECTIONS (objfile, osect)
- if (section_is_overlay (osect->the_bfd_section))
+ if (section_is_overlay (osect))
{
- if (pc_in_mapped_range (pc, osect->the_bfd_section))
+ if (pc_in_mapped_range (pc, osect))
{
- if (overlay_is_mapped (osect))
- return osect->the_bfd_section;
+ if (section_is_mapped (osect))
+ return osect;
else
best_match = osect;
}
- else if (pc_in_unmapped_range (pc, osect->the_bfd_section))
+ else if (pc_in_unmapped_range (pc, osect))
best_match = osect;
}
- return best_match ? best_match->the_bfd_section : NULL;
+ return best_match;
}
/* Function: find_pc_mapped_section (PC)
If PC falls into the VMA address range of an overlay section that is
currently marked as MAPPED, return that section. Else return NULL. */
-asection *
+struct obj_section *
find_pc_mapped_section (CORE_ADDR pc)
{
struct objfile *objfile;
if (overlay_debugging)
ALL_OBJSECTIONS (objfile, osect)
- if (pc_in_mapped_range (pc, osect->the_bfd_section) &&
- overlay_is_mapped (osect))
- return osect->the_bfd_section;
+ if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
+ return osect;
return NULL;
}
if (overlay_debugging)
ALL_OBJSECTIONS (objfile, osect)
- if (overlay_is_mapped (osect))
+ if (section_is_mapped (osect))
{
const char *name;
bfd_vma lma, vma;
name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
printf_filtered ("Section %s, loaded at ", name);
- deprecated_print_address_numeric (lma, 1, gdb_stdout);
+ fputs_filtered (paddress (lma), gdb_stdout);
puts_filtered (" - ");
- deprecated_print_address_numeric (lma + size, 1, gdb_stdout);
+ fputs_filtered (paddress (lma + size), gdb_stdout);
printf_filtered (", mapped at ");
- deprecated_print_address_numeric (vma, 1, gdb_stdout);
+ fputs_filtered (paddress (vma), gdb_stdout);
puts_filtered (" - ");
- deprecated_print_address_numeric (vma + size, 1, gdb_stdout);
+ fputs_filtered (paddress (vma + size), gdb_stdout);
puts_filtered ("\n");
nmapped++;
{
struct objfile *objfile, *objfile2;
struct obj_section *sec, *sec2;
- asection *bfdsec;
if (!overlay_debugging)
error (_("\
if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
{
/* Now, check to see if the section is an overlay. */
- bfdsec = sec->the_bfd_section;
- if (!section_is_overlay (bfdsec))
+ if (!section_is_overlay (sec))
continue; /* not an overlay section */
/* Mark the overlay as "mapped" */
/* Next, make a pass and unmap any sections that are
overlapped by this new section: */
ALL_OBJSECTIONS (objfile2, sec2)
- if (sec2->ovly_mapped
- && sec != sec2
- && sec->the_bfd_section != sec2->the_bfd_section
- && sections_overlap (sec->the_bfd_section,
- sec2->the_bfd_section))
+ if (sec2->ovly_mapped && sec != sec2 && sections_overlap (sec, sec2))
{
if (info_verbose)
printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
/* Now may as well update all sections, even if only one was requested. */
ALL_OBJSECTIONS (objfile, osect)
- if (section_is_overlay (osect->the_bfd_section))
+ if (section_is_overlay (osect))
{
int i, size;
bfd *obfd = osect->objfile->obfd;
return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
}
+struct symfile_segment_data *
+get_symfile_segment_data (bfd *abfd)
+{
+ struct sym_fns *sf = find_sym_fns (abfd);
+
+ if (sf == NULL)
+ return NULL;
+
+ return sf->sym_segments (abfd);
+}
+
+void
+free_symfile_segment_data (struct symfile_segment_data *data)
+{
+ xfree (data->segment_bases);
+ xfree (data->segment_sizes);
+ xfree (data->segment_info);
+ xfree (data);
+}
+
+
+/* Given:
+ - DATA, containing segment addresses from the object file ABFD, and
+ the mapping from ABFD's sections onto the segments that own them,
+ and
+ - SEGMENT_BASES[0 .. NUM_SEGMENT_BASES - 1], holding the actual
+ segment addresses reported by the target,
+ store the appropriate offsets for each section in OFFSETS.
+
+ If there are fewer entries in SEGMENT_BASES than there are segments
+ in DATA, then apply SEGMENT_BASES' last entry to all the segments.
+
+ If there are more entries, then ignore the extra. The target may
+ not be able to distinguish between an empty data segment and a
+ missing data segment; a missing text segment is less plausible. */
+int
+symfile_map_offsets_to_segments (bfd *abfd, struct symfile_segment_data *data,
+ struct section_offsets *offsets,
+ int num_segment_bases,
+ const CORE_ADDR *segment_bases)
+{
+ int i;
+ asection *sect;
+
+ /* It doesn't make sense to call this function unless you have some
+ segment base addresses. */
+ gdb_assert (segment_bases > 0);
+
+ /* If we do not have segment mappings for the object file, we
+ can not relocate it by segments. */
+ gdb_assert (data != NULL);
+ gdb_assert (data->num_segments > 0);
+
+ for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
+ {
+ int which = data->segment_info[i];
+
+ gdb_assert (0 <= which && which <= data->num_segments);
+
+ /* Don't bother computing offsets for sections that aren't
+ loaded as part of any segment. */
+ if (! which)
+ continue;
+
+ /* Use the last SEGMENT_BASES entry as the address of any extra
+ segments mentioned in DATA->segment_info. */
+ if (which > num_segment_bases)
+ which = num_segment_bases;
+
+ offsets->offsets[i] = (segment_bases[which - 1]
+ - data->segment_bases[which - 1]);
+ }
+
+ return 1;
+}
+
+static void
+symfile_find_segment_sections (struct objfile *objfile)
+{
+ bfd *abfd = objfile->obfd;
+ int i;
+ asection *sect;
+ struct symfile_segment_data *data;
+
+ data = get_symfile_segment_data (objfile->obfd);
+ if (data == NULL)
+ return;
+
+ if (data->num_segments != 1 && data->num_segments != 2)
+ {
+ free_symfile_segment_data (data);
+ return;
+ }
+
+ for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
+ {
+ CORE_ADDR vma;
+ int which = data->segment_info[i];
+
+ if (which == 1)
+ {
+ if (objfile->sect_index_text == -1)
+ objfile->sect_index_text = sect->index;
+
+ if (objfile->sect_index_rodata == -1)
+ objfile->sect_index_rodata = sect->index;
+ }
+ else if (which == 2)
+ {
+ if (objfile->sect_index_data == -1)
+ objfile->sect_index_data = sect->index;
+
+ if (objfile->sect_index_bss == -1)
+ objfile->sect_index_bss = sect->index;
+ }
+ }
+
+ free_symfile_segment_data (data);
+}
+
void
_initialize_symfile (void)
{
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);
}