/* 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, 2008, 2009, 2010
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
#include <time.h>
#include <sys/time.h>
+#include "psymtab.h"
-int (*deprecated_ui_load_progress_hook) (const char *section, unsigned long num);
+int (*deprecated_ui_load_progress_hook) (const char *section,
+ unsigned long num);
void (*deprecated_show_load_progress) (const char *section,
unsigned long section_sent,
unsigned long section_size,
/* Functions this file defines */
-#if 0
-static int simple_read_overlay_region_table (void);
-static void simple_free_overlay_region_table (void);
-#endif
-
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 struct sym_fns *find_sym_fns (bfd *);
+static const struct sym_fns *find_sym_fns (bfd *);
static void decrement_reading_symtab (void *);
calls add_symtab_fns() to register information on each format it is
prepared to read. */
-static struct sym_fns *symtab_fns = NULL;
+typedef const struct sym_fns *sym_fns_ptr;
+DEF_VEC_P (sym_fns_ptr);
+
+static VEC (sym_fns_ptr) *symtab_fns = NULL;
/* Flag for whether user will be reloading symbols multiple times.
Defaults to ON for VxWorks, otherwise OFF. */
show_symbol_reloading (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Dynamic symbol table reloading multiple times in one run is %s.\n"),
+ fprintf_filtered (file, _("Dynamic symbol table reloading "
+ "multiple times in one run is %s.\n"),
value);
}
this flag and then add the shared library symbols as needed. Note
that there is a potential for confusion, since if the shared
library symbols are not loaded, commands like "info fun" will *not*
- report all the functions that are actually present. */
+ report all the functions that are actually present. */
int auto_solib_add = 1;
size to exceed this threshhold, then the shlib's symbols are not
added. The threshold is ignored if the user explicitly asks for a
shlib to be added, such as when using the "sharedlibrary"
- command. */
+ command. */
int auto_solib_limit;
\f
-/* This compares two partial symbols by names, using strcmp_iw_ordered
- for the comparison. */
-
-static int
-compare_psymbols (const void *s1p, const void *s2p)
-{
- struct partial_symbol *const *s1 = s1p;
- struct partial_symbol *const *s2 = s2p;
-
- return strcmp_iw_ordered (SYMBOL_SEARCH_NAME (*s1),
- SYMBOL_SEARCH_NAME (*s2));
-}
-
-void
-sort_pst_symbols (struct partial_symtab *pst)
-{
- /* Sort the global list; don't sort the static list */
-
- qsort (pst->objfile->global_psymbols.list + pst->globals_offset,
- pst->n_global_syms, sizeof (struct partial_symbol *),
- compare_psymbols);
-}
-
/* Make a null terminated copy of the string at PTR with SIZE characters in
the obstack pointed to by OBSTACKP . Returns the address of the copy.
Note that the string at PTR does not have to be null terminated, I.E. it
- may be part of a larger string and we are only saving a substring. */
+ may be part of a larger string and we are only saving a substring. */
char *
obsavestring (const char *ptr, int size, struct obstack *obstackp)
const char *p1 = ptr;
char *p2 = p;
const char *end = ptr + size;
+
while (p1 != end)
*p2++ = *p1++;
}
return p;
}
-/* Concatenate strings S1, S2 and S3; return the new string. Space is found
- in the obstack pointed to by OBSTACKP. */
+/* Concatenate NULL terminated variable argument list of `const char *'
+ strings; return the new string. Space is found in the OBSTACKP.
+ Argument list must be terminated by a sentinel expression `(char *)
+ NULL'. */
char *
-obconcat (struct obstack *obstackp, const char *s1, const char *s2,
- const char *s3)
+obconcat (struct obstack *obstackp, ...)
{
- int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
- char *val = (char *) obstack_alloc (obstackp, len);
- strcpy (val, s1);
- strcat (val, s2);
- strcat (val, s3);
- return val;
+ va_list ap;
+
+ va_start (ap, obstackp);
+ for (;;)
+ {
+ const char *s = va_arg (ap, const char *);
+
+ if (s == NULL)
+ break;
+
+ obstack_grow_str (obstackp, s);
+ }
+ va_end (ap);
+ obstack_1grow (obstackp, 0);
+
+ return obstack_finish (obstackp);
}
-/* True if we are nested inside psymtab_to_symtab. */
+/* True if we are reading a symbol table. */
int currently_reading_symtab = 0;
currently_reading_symtab--;
}
-/* Get the symbol table that corresponds to a partial_symtab.
- This is fast after the first time you do it. In fact, there
- is an even faster macro PSYMTAB_TO_SYMTAB that does the fast
- case inline. */
-
-struct symtab *
-psymtab_to_symtab (struct partial_symtab *pst)
+/* Increment currently_reading_symtab and return a cleanup that can be
+ used to decrement it. */
+struct cleanup *
+increment_reading_symtab (void)
{
- /* If it's been looked up before, return it. */
- if (pst->symtab)
- return pst->symtab;
-
- /* If it has not yet been read in, read it. */
- if (!pst->readin)
- {
- struct cleanup *back_to = make_cleanup (decrement_reading_symtab, NULL);
- currently_reading_symtab++;
- (*pst->read_symtab) (pst);
- do_cleanups (back_to);
- }
-
- return pst->symtab;
+ ++currently_reading_symtab;
+ return make_cleanup (decrement_reading_symtab, NULL);
}
/* Remember the lowest-addressed loadable section we've seen.
{
asection **lowest = (asection **) obj;
- if (0 == (bfd_get_section_flags (abfd, sect) & SEC_LOAD))
+ if (0 == (bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD)))
return;
if (!*lowest)
*lowest = sect; /* First loadable section */
return sap;
}
+/* Create a section_addr_info from section offsets in ABFD. */
+
+static struct section_addr_info *
+build_section_addr_info_from_bfd (bfd *abfd)
+{
+ struct section_addr_info *sap;
+ int i;
+ struct bfd_section *sec;
+
+ sap = alloc_section_addr_info (bfd_count_sections (abfd));
+ for (i = 0, sec = abfd->sections; sec != NULL; sec = sec->next)
+ if (bfd_get_section_flags (abfd, sec) & (SEC_ALLOC | SEC_LOAD))
+ {
+ sap->other[i].addr = bfd_get_section_vma (abfd, sec);
+ sap->other[i].name = xstrdup (bfd_get_section_name (abfd, sec));
+ sap->other[i].sectindex = sec->index;
+ i++;
+ }
+ return sap;
+}
+
/* Create a section_addr_info from section offsets in OBJFILE. */
struct section_addr_info *
{
struct section_addr_info *sap;
int i;
- struct bfd_section *sec;
- int addr_bit = gdbarch_addr_bit (objfile->gdbarch);
- CORE_ADDR mask = CORE_ADDR_MAX;
- if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
- mask = ((CORE_ADDR) 1 << addr_bit) - 1;
-
- sap = alloc_section_addr_info (objfile->num_sections);
- for (i = 0, sec = objfile->obfd->sections;
- i < objfile->num_sections;
- i++, sec = sec->next)
+ /* Before reread_symbols gets rewritten it is not safe to call:
+ gdb_assert (objfile->num_sections == bfd_count_sections (objfile->obfd));
+ */
+ sap = build_section_addr_info_from_bfd (objfile->obfd);
+ for (i = 0; i < sap->num_sections && sap->other[i].name; i++)
{
- gdb_assert (sec != NULL);
- sap->other[i].addr = (bfd_get_section_vma (objfile->obfd, sec)
- + objfile->section_offsets->offsets[i]) & mask;
- sap->other[i].name = xstrdup (bfd_get_section_name (objfile->obfd, sec));
- sap->other[i].sectindex = sec->index;
+ int sectindex = sap->other[i].sectindex;
+
+ sap->other[i].addr += objfile->section_offsets->offsets[sectindex];
}
return sap;
}
-
/* Free all memory allocated by build_section_addr_info_from_section_table. */
extern void
for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
{
int indx = cur_sec->index;
- CORE_ADDR cur_offset;
/* We don't need to compare against ourself. */
if (cur_sec == sect)
}
}
+/* Transform section name S for a name comparison. prelink can split section
+ `.bss' into two sections `.dynbss' and `.bss' (in this order). Similarly
+ prelink can split `.sbss' into `.sdynbss' and `.sbss'. Use virtual address
+ of the new `.dynbss' (`.sdynbss') section as the adjacent new `.bss'
+ (`.sbss') section has invalid (increased) virtual address. */
+
+static const char *
+addr_section_name (const char *s)
+{
+ if (strcmp (s, ".dynbss") == 0)
+ return ".bss";
+ if (strcmp (s, ".sdynbss") == 0)
+ return ".sbss";
+
+ return s;
+}
+
+/* qsort comparator for addrs_section_sort. Sort entries in ascending order by
+ their (name, sectindex) pair. sectindex makes the sort by name stable. */
+
+static int
+addrs_section_compar (const void *ap, const void *bp)
+{
+ const struct other_sections *a = *((struct other_sections **) ap);
+ const struct other_sections *b = *((struct other_sections **) bp);
+ int retval, a_idx, b_idx;
+
+ retval = strcmp (addr_section_name (a->name), addr_section_name (b->name));
+ if (retval)
+ return retval;
+
+ /* SECTINDEX is undefined iff ADDR is zero. */
+ a_idx = a->addr == 0 ? 0 : a->sectindex;
+ b_idx = b->addr == 0 ? 0 : b->sectindex;
+ return a_idx - b_idx;
+}
+
+/* Provide sorted array of pointers to sections of ADDRS. The array is
+ terminated by NULL. Caller is responsible to call xfree for it. */
+
+static struct other_sections **
+addrs_section_sort (struct section_addr_info *addrs)
+{
+ struct other_sections **array;
+ int i;
+
+ /* `+ 1' for the NULL terminator. */
+ array = xmalloc (sizeof (*array) * (addrs->num_sections + 1));
+ for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
+ array[i] = &addrs->other[i];
+ array[i] = NULL;
+
+ qsort (array, i, sizeof (*array), addrs_section_compar);
+
+ return array;
+}
+
/* Relativize absolute addresses in ADDRS into offsets based on ABFD. Fill-in
- also SECTINDEXes there. */
+ also SECTINDEXes specific to ABFD there. This function can be used to
+ rebase ADDRS to start referencing different BFD than before. */
void
addr_info_make_relative (struct section_addr_info *addrs, bfd *abfd)
{
asection *lower_sect;
- asection *sect;
CORE_ADDR lower_offset;
int i;
+ struct cleanup *my_cleanup;
+ struct section_addr_info *abfd_addrs;
+ struct other_sections **addrs_sorted, **abfd_addrs_sorted;
+ struct other_sections **addrs_to_abfd_addrs;
/* Find lowest loadable section to be used as starting point for
- continguous sections. FIXME!! won't work without call to find
- .text first, but this assumes text is lowest section. */
- lower_sect = bfd_get_section_by_name (abfd, ".text");
- if (lower_sect == NULL)
- bfd_map_over_sections (abfd, find_lowest_section, &lower_sect);
+ continguous sections. */
+ lower_sect = NULL;
+ bfd_map_over_sections (abfd, find_lowest_section, &lower_sect);
if (lower_sect == NULL)
{
warning (_("no loadable sections found in added symbol-file %s"),
else
lower_offset = bfd_section_vma (bfd_get_filename (abfd), lower_sect);
+ /* Create ADDRS_TO_ABFD_ADDRS array to map the sections in ADDRS to sections
+ in ABFD. Section names are not unique - there can be multiple sections of
+ the same name. Also the sections of the same name do not have to be
+ adjacent to each other. Some sections may be present only in one of the
+ files. Even sections present in both files do not have to be in the same
+ order.
+
+ Use stable sort by name for the sections in both files. Then linearly
+ scan both lists matching as most of the entries as possible. */
+
+ addrs_sorted = addrs_section_sort (addrs);
+ my_cleanup = make_cleanup (xfree, addrs_sorted);
+
+ abfd_addrs = build_section_addr_info_from_bfd (abfd);
+ make_cleanup_free_section_addr_info (abfd_addrs);
+ abfd_addrs_sorted = addrs_section_sort (abfd_addrs);
+ make_cleanup (xfree, abfd_addrs_sorted);
+
+ /* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and ABFD_ADDRS_SORTED. */
+
+ addrs_to_abfd_addrs = xzalloc (sizeof (*addrs_to_abfd_addrs)
+ * addrs->num_sections);
+ make_cleanup (xfree, addrs_to_abfd_addrs);
+
+ while (*addrs_sorted)
+ {
+ const char *sect_name = addr_section_name ((*addrs_sorted)->name);
+
+ while (*abfd_addrs_sorted
+ && strcmp (addr_section_name ((*abfd_addrs_sorted)->name),
+ sect_name) < 0)
+ abfd_addrs_sorted++;
+
+ if (*abfd_addrs_sorted
+ && strcmp (addr_section_name ((*abfd_addrs_sorted)->name),
+ sect_name) == 0)
+ {
+ int index_in_addrs;
+
+ /* Make the found item directly addressable from ADDRS. */
+ index_in_addrs = *addrs_sorted - addrs->other;
+ gdb_assert (addrs_to_abfd_addrs[index_in_addrs] == NULL);
+ addrs_to_abfd_addrs[index_in_addrs] = *abfd_addrs_sorted;
+
+ /* Never use the same ABFD entry twice. */
+ abfd_addrs_sorted++;
+ }
+
+ addrs_sorted++;
+ }
+
/* Calculate offsets for the loadable sections.
FIXME! Sections must be in order of increasing loadable section
so that contiguous sections can use the lower-offset!!!
for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
{
- if (addrs->other[i].addr != 0)
+ struct other_sections *sect = addrs_to_abfd_addrs[i];
+
+ if (sect)
{
- sect = bfd_get_section_by_name (abfd, addrs->other[i].name);
- if (sect)
+ /* This is the index used by BFD. */
+ addrs->other[i].sectindex = sect->sectindex;
+
+ if (addrs->other[i].addr != 0)
{
- addrs->other[i].addr -= bfd_section_vma (abfd, sect);
+ addrs->other[i].addr -= sect->addr;
lower_offset = addrs->other[i].addr;
- /* This is the index used by BFD. */
- addrs->other[i].sectindex = sect->index;
}
else
- {
- warning (_("section %s not found in %s"), addrs->other[i].name,
- bfd_get_filename (abfd));
- addrs->other[i].addr = 0;
- }
+ addrs->other[i].addr = lower_offset;
}
else
- addrs->other[i].addr = lower_offset;
+ {
+ /* addr_section_name transformation is not used for SECT_NAME. */
+ const char *sect_name = addrs->other[i].name;
+
+ /* This section does not exist in ABFD, which is normally
+ unexpected and we want to issue a warning.
+
+ However, the ELF prelinker does create a few sections which are
+ marked in the main executable as loadable (they are loaded in
+ memory from the DYNAMIC segment) and yet are not present in
+ separate debug info files. This is fine, and should not cause
+ a warning. Shared libraries contain just the section
+ ".gnu.liblist" but it is not marked as loadable there. There is
+ no other way to identify them than by their name as the sections
+ created by prelink have no special flags.
+
+ For the sections `.bss' and `.sbss' see addr_section_name. */
+
+ if (!(strcmp (sect_name, ".gnu.liblist") == 0
+ || strcmp (sect_name, ".gnu.conflict") == 0
+ || (strcmp (sect_name, ".bss") == 0
+ && i > 0
+ && strcmp (addrs->other[i - 1].name, ".dynbss") == 0
+ && addrs_to_abfd_addrs[i - 1] != NULL)
+ || (strcmp (sect_name, ".sbss") == 0
+ && i > 0
+ && strcmp (addrs->other[i - 1].name, ".sdynbss") == 0
+ && addrs_to_abfd_addrs[i - 1] != NULL)))
+ warning (_("section %s not found in %s"), sect_name,
+ bfd_get_filename (abfd));
+
+ addrs->other[i].addr = 0;
+
+ /* SECTINDEX is invalid if ADDR is zero. */
+ }
}
+
+ do_cleanups (my_cleanup);
}
/* Parse the user's idea of an offset for dynamic linking, into our idea
struct place_section_arg arg;
bfd *abfd = objfile->obfd;
asection *cur_sec;
- CORE_ADDR lowest = 0;
for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
/* We do not expect this to happen; just skip this step if the
continue;
bfd_set_section_vma (abfd, cur_sec, offsets[cur_sec->index]);
- exec_set_section_address (bfd_get_filename (abfd), cur_sec->index,
+ exec_set_section_address (bfd_get_filename (abfd),
+ cur_sec->index,
offsets[cur_sec->index]);
offsets[cur_sec->index] = 0;
}
/* Perform required actions after either reading in the initial
symbols for a new objfile, or mapping in the symbols from a reusable
- objfile. */
+ objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
void
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. */
/* OK, make it the "real" symbol file. */
symfile_objfile = objfile;
- clear_symtab_users ();
+ clear_symtab_users (add_flags);
}
else if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
{
int flags)
{
struct objfile *objfile;
- struct partial_symtab *psymtab;
struct cleanup *my_cleanups;
const char *name = bfd_get_filename (abfd);
const int from_tty = add_flags & SYMFILE_VERBOSE;
+ if (readnow_symbol_files)
+ flags |= OBJF_READNOW;
+
my_cleanups = make_cleanup_bfd_close (abfd);
/* Give user a chance to burp if we'd be
the gdb startup command line or on a per symbol file basis. Expand
all partial symbol tables for this objfile if so. */
- if ((flags & OBJF_READNOW) || readnow_symbol_files)
+ if ((flags & OBJF_READNOW))
{
if (from_tty || info_verbose)
{
gdb_flush (gdb_stdout);
}
- for (psymtab = objfile->psymtabs;
- psymtab != NULL;
- psymtab = psymtab->next)
- {
- psymtab_to_symtab (psymtab);
- }
+ if (objfile->sf)
+ objfile->sf->qf->expand_all_symtabs (objfile);
}
if ((from_tty || info_verbose)
: !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. */
+ /* solib descriptors may have handles to objfiles. Wipe them before their
+ objfiles get stale by free_all_objfiles. */
no_shared_libraries (NULL, from_tty);
+ free_all_objfiles ();
+
gdb_assert (symfile_objfile == NULL);
if (from_tty)
printf_unfiltered (_("No symbol file now.\n"));
unsigned long crc32;
char *contents;
int crc_offset;
- unsigned char *p;
sect = bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink");
show_debug_file_directory (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-The directory where separate debug symbols are searched for is \"%s\".\n"),
+ fprintf_filtered (file,
+ _("The directory where separate debug "
+ "symbols are searched for is \"%s\".\n"),
value);
}
char *
find_separate_debug_file_by_debuglink (struct objfile *objfile)
{
- asection *sect;
- char *basename, *name_copy, *debugdir;
+ char *basename, *debugdir;
char *dir = NULL;
char *debugfile = NULL;
char *canon_name = NULL;
- bfd_size_type debuglink_size;
unsigned long crc32;
int i;
dir = xstrdup (objfile->name);
/* Strip off the final filename part, leaving the directory name,
- followed by a slash. Objfile names should always be absolute and
- tilde-expanded, so there should always be a slash in there
- somewhere. */
+ followed by a slash. The directory can be relative or absolute. */
for (i = strlen(dir) - 1; i >= 0; i--)
{
if (IS_DIR_SEPARATOR (dir[i]))
break;
}
- gdb_assert (i >= 0 && IS_DIR_SEPARATOR (dir[i]));
+ /* If I is -1 then no directory is present there and DIR will be "". */
dir[i+1] = '\0';
/* Set I to max (strlen (canon_name), strlen (dir)). */
void
set_initial_language (void)
{
- struct partial_symtab *pst;
enum language lang = language_unknown;
- pst = find_main_psymtab ();
- if (pst != NULL)
+ if (language_of_main != language_unknown)
+ lang = language_of_main;
+ else
{
- if (pst->filename != NULL)
- lang = deduce_language_from_filename (pst->filename);
-
- if (lang == language_unknown)
- {
- /* Make C the default language */
- lang = language_c;
- }
+ const char *filename;
+
+ filename = find_main_filename ();
+ if (filename != NULL)
+ lang = deduce_language_from_filename (filename);
+ }
- set_language (lang);
- expected_language = current_language; /* Don't warn the user. */
+ if (lang == language_unknown)
+ {
+ /* Make C the default language */
+ lang = language_c;
}
+
+ set_language (lang);
+ expected_language = current_language; /* Don't warn the user. */
}
/* If NAME is a remote name open the file using remote protocol, otherwise
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, &absolute_name);
handle. */
void
-add_symtab_fns (struct sym_fns *sf)
+add_symtab_fns (const struct sym_fns *sf)
{
- sf->next = symtab_fns;
- symtab_fns = sf;
+ VEC_safe_push (sym_fns_ptr, symtab_fns, sf);
}
/* Initialize OBJFILE to read symbols from its associated BFD. It
struct sym_fns in the objfile structure, that contains cached
information about the symbol file. */
-static struct sym_fns *
+static const struct sym_fns *
find_sym_fns (bfd *abfd)
{
- struct sym_fns *sf;
+ const struct sym_fns *sf;
enum bfd_flavour our_flavour = bfd_get_flavour (abfd);
+ int i;
if (our_flavour == bfd_target_srec_flavour
|| our_flavour == bfd_target_ihex_flavour
|| our_flavour == bfd_target_tekhex_flavour)
return NULL; /* No symbols. */
- for (sf = symtab_fns; sf != NULL; sf = sf->next)
+ for (i = 0; VEC_iterate (sym_fns_ptr, symtab_fns, i, sf); ++i)
if (our_flavour == sf->sym_flavour)
return sf;
static void
load_command (char *arg, int from_tty)
{
+ dont_repeat ();
+
/* The user might be reloading because the binary has changed. Take
this opportunity to check. */
reopen_exec_file ();
memset (new_request, 0, sizeof (struct memory_write_request));
section_data = xcalloc (1, sizeof (struct load_progress_section_data));
new_request->begin = bfd_section_lma (abfd, asec) + args->load_offset;
- new_request->end = new_request->begin + size; /* FIXME Should size be in instead? */
+ new_request->end = new_request->begin + size; /* FIXME Should size
+ be in instead? */
new_request->data = xmalloc (size);
new_request->baton = section_data;
for other targets too. */
regcache_write_pc (get_current_regcache (), entry);
+ /* Reset breakpoints, now that we have changed the load image. For
+ instance, breakpoints may have been set (or reset, by
+ post_create_inferior) while connected to the target but before we
+ loaded the program. In that case, the prologue analyzer could
+ have read instructions from the target to find the right
+ breakpoint locations. Loading has changed the contents of that
+ memory. */
+
+ breakpoint_re_set ();
+
/* 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
was commented out), making the call confuses GDB if more than one
char *filename = NULL;
int flags = OBJF_USERLOADED;
char *arg;
- int expecting_option = 0;
int section_index = 0;
int argcnt = 0;
int sec_num = 0;
}
}
else
- error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
+ error (_("USAGE: add-symbol-file <filename> <textaddress>"
+ " [-mapped] [-readnow] [-s <secname> <addr>]*"));
}
}
}
if (objfile->separate_debug_objfile_backlink)
continue;
-#ifdef DEPRECATED_IBM6000_TARGET
- /* If this object is from a shared library, then you should
- stat on the library name, not member name. */
-
+ /* If this object is from an archive (what you usually create with
+ `ar', often called a `static library' on most systems, though
+ a `shared library' on AIX is also an archive), then you should
+ stat on the archive name, not member name. */
if (objfile->obfd->my_archive)
res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
else
-#endif
res = stat (objfile->name, &new_statbuf);
if (res != 0)
{
sizeof (objfile->static_psymbols));
/* Free the obstacks for non-reusable objfiles */
- bcache_xfree (objfile->psymbol_cache);
- objfile->psymbol_cache = bcache_xmalloc ();
+ psymbol_bcache_free (objfile->psymbol_cache);
+ objfile->psymbol_cache = psymbol_bcache_init ();
bcache_xfree (objfile->macro_cache);
- objfile->macro_cache = bcache_xmalloc ();
+ objfile->macro_cache = bcache_xmalloc (NULL, NULL);
bcache_xfree (objfile->filename_cache);
- objfile->filename_cache = bcache_xmalloc ();
+ objfile->filename_cache = bcache_xmalloc (NULL,NULL);
if (objfile->demangled_names_hash != NULL)
{
htab_delete (objfile->demangled_names_hash);
objfile->psymtabs_addrmap = NULL;
objfile->free_psymtabs = NULL;
objfile->cp_namespace_symtab = NULL;
+ objfile->template_symbols = NULL;
objfile->msymbols = NULL;
objfile->deprecated_sym_private = NULL;
objfile->minimal_symbol_count = 0;
memset (&objfile->msymbol_demangled_hash, 0,
sizeof (objfile->msymbol_demangled_hash));
- objfile->psymbol_cache = bcache_xmalloc ();
- objfile->macro_cache = bcache_xmalloc ();
- objfile->filename_cache = bcache_xmalloc ();
+ objfile->psymbol_cache = psymbol_bcache_init ();
+ objfile->macro_cache = bcache_xmalloc (NULL, NULL);
+ objfile->filename_cache = bcache_xmalloc (NULL, NULL);
/* obstack_init also initializes the obstack so it is
empty. We could use obstack_specify_allocation but
gdb_obstack.h specifies the alloc/dealloc
/* Notify objfiles that we've modified objfile sections. */
objfiles_changed ();
- clear_symtab_users ();
+ clear_symtab_users (0);
/* At least one objfile has changed, so we can consider that
the executable we're debugging has changed too. */
observer_notify_executable_changed ();
show_ext_args (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Mapping between filename extension and source language is \"%s\".\n"),
+ fprintf_filtered (file,
+ _("Mapping between filename extension "
+ "and source language is \"%s\".\n"),
value);
}
cp++;
if (*cp == '\0')
- error (_("'%s': two arguments required -- filename extension and language"),
+ error (_("'%s': two arguments required -- "
+ "filename extension and language"),
ext_args);
/* Null-terminate first arg */
cp++;
if (*cp == '\0')
- error (_("'%s': two arguments required -- filename extension and language"),
+ error (_("'%s': two arguments required -- "
+ "filename extension and language"),
ext_args);
/* Lookup the language from among those we know. */
filename_language_table =
xmalloc (fl_table_size * sizeof (*filename_language_table));
add_filename_language (".c", language_c);
+ add_filename_language (".d", language_d);
add_filename_language (".C", language_cplus);
add_filename_language (".cc", language_cplus);
add_filename_language (".cp", language_cplus);
add_filename_language (".m", language_objc);
add_filename_language (".f", language_fortran);
add_filename_language (".F", language_fortran);
+ add_filename_language (".for", language_fortran);
+ add_filename_language (".FOR", language_fortran);
+ add_filename_language (".ftn", language_fortran);
+ add_filename_language (".FTN", language_fortran);
+ add_filename_language (".fpp", language_fortran);
+ add_filename_language (".FPP", language_fortran);
+ add_filename_language (".f90", language_fortran);
+ add_filename_language (".F90", language_fortran);
+ add_filename_language (".f95", language_fortran);
+ add_filename_language (".F95", language_fortran);
+ add_filename_language (".f03", language_fortran);
+ add_filename_language (".F03", language_fortran);
+ add_filename_language (".f08", language_fortran);
+ add_filename_language (".F08", language_fortran);
add_filename_language (".s", language_asm);
add_filename_language (".sx", language_asm);
add_filename_language (".S", language_asm);
add_filename_language (".ads", language_ada);
add_filename_language (".a", language_ada);
add_filename_language (".ada", language_ada);
+ add_filename_language (".dg", language_ada);
}
}
enum language
-deduce_language_from_filename (char *filename)
+deduce_language_from_filename (const char *filename)
{
int i;
char *cp;
*/
struct symtab *
-allocate_symtab (char *filename, struct objfile *objfile)
+allocate_symtab (const char *filename, struct objfile *objfile)
{
struct symtab *symtab;
return (symtab);
}
-
-struct partial_symtab *
-allocate_psymtab (const char *filename, struct objfile *objfile)
-{
- struct partial_symtab *psymtab;
-
- if (objfile->free_psymtabs)
- {
- psymtab = objfile->free_psymtabs;
- objfile->free_psymtabs = psymtab->next;
- }
- else
- psymtab = (struct partial_symtab *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct partial_symtab));
-
- memset (psymtab, 0, sizeof (struct partial_symtab));
- 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.
- Psymtabs are searched in most recent inserted -> least recent
- inserted order. */
-
- psymtab->objfile = objfile;
- psymtab->next = objfile->psymtabs;
- objfile->psymtabs = psymtab;
-#if 0
- {
- struct partial_symtab **prev_pst;
- psymtab->objfile = objfile;
- psymtab->next = NULL;
- prev_pst = &(objfile->psymtabs);
- while ((*prev_pst) != NULL)
- prev_pst = &((*prev_pst)->next);
- (*prev_pst) = psymtab;
- }
-#endif
-
- return (psymtab);
-}
-
-void
-discard_psymtab (struct partial_symtab *pst)
-{
- struct partial_symtab **prev_pst;
-
- /* From dbxread.c:
- Empty psymtabs happen as a result of header files which don't
- have any symbols in them. There can be a lot of them. But this
- check is wrong, in that a psymtab with N_SLINE entries but
- nothing else is not empty, but we don't realize that. Fixing
- that without slowing things down might be tricky. */
-
- /* First, snip it out of the psymtab chain */
-
- prev_pst = &(pst->objfile->psymtabs);
- while ((*prev_pst) != pst)
- prev_pst = &((*prev_pst)->next);
- (*prev_pst) = pst->next;
-
- /* Next, put it on a free list for recycling */
-
- pst->next = pst->objfile->free_psymtabs;
- pst->objfile->free_psymtabs = pst;
-}
\f
/* Reset all data structures in gdb which may contain references to symbol
- table data. */
+ table data. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
void
-clear_symtab_users (void)
+clear_symtab_users (int add_flags)
{
/* Someday, we should do better than this, by only blowing away
the things that really need to be blown. */
clear_current_source_symtab_and_line ();
clear_displays ();
- breakpoint_re_set ();
+ if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
+ breakpoint_re_set ();
set_default_breakpoint (0, NULL, 0, 0, 0);
clear_pc_function_cache ();
observer_notify_new_objfile (NULL);
static void
clear_symtab_users_cleanup (void *ignore)
{
- clear_symtab_users ();
+ clear_symtab_users (0);
}
\f
-/* Allocate and partially fill a partial symtab. It will be
- completely filled at the end of the symbol list.
-
- FILENAME is the name of the symbol-file we are reading from. */
-
-struct partial_symtab *
-start_psymtab_common (struct objfile *objfile,
- struct section_offsets *section_offsets,
- const char *filename,
- CORE_ADDR textlow, struct partial_symbol **global_syms,
- struct partial_symbol **static_syms)
-{
- struct partial_symtab *psymtab;
-
- psymtab = allocate_psymtab (filename, objfile);
- psymtab->section_offsets = section_offsets;
- psymtab->textlow = textlow;
- psymtab->texthigh = psymtab->textlow; /* default */
- psymtab->globals_offset = global_syms - objfile->global_psymbols.list;
- psymtab->statics_offset = static_syms - objfile->static_psymbols.list;
- return (psymtab);
-}
-\f
-/* 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, 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)
-{
- /* 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;
-
- /* 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)
- {
- SYMBOL_VALUE (&psymbol) = val;
- }
- else
- {
- SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr;
- }
- SYMBOL_SECTION (&psymbol) = 0;
- SYMBOL_LANGUAGE (&psymbol) = language;
- PSYMBOL_DOMAIN (&psymbol) = domain;
- PSYMBOL_CLASS (&psymbol) = class;
-
- 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),
- objfile->psymbol_cache, added);
-}
-
-/* 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++ = (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, int copy_name,
- 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, copy_name, 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;
-}
-
-/* Initialize storage for partial symbols. */
-
-void
-init_psymbol_list (struct objfile *objfile, int total_symbols)
-{
- /* Free any previously allocated psymbol lists. */
-
- if (objfile->global_psymbols.list)
- {
- xfree (objfile->global_psymbols.list);
- }
- if (objfile->static_psymbols.list)
- {
- xfree (objfile->static_psymbols.list);
- }
-
- /* Current best guess is that approximately a twentieth
- of the total symbols (in a debugging file) are global or static
- oriented symbols */
-
- objfile->global_psymbols.size = total_symbols / 10;
- objfile->static_psymbols.size = total_symbols / 10;
-
- if (objfile->global_psymbols.size > 0)
- {
- objfile->global_psymbols.next =
- objfile->global_psymbols.list = (struct partial_symbol **)
- xmalloc ((objfile->global_psymbols.size
- * sizeof (struct partial_symbol *)));
- }
- if (objfile->static_psymbols.size > 0)
- {
- objfile->static_psymbols.next =
- objfile->static_psymbols.list = (struct partial_symbol **)
- xmalloc ((objfile->static_psymbols.size
- * sizeof (struct partial_symbol *)));
- }
-}
-
/* OVERLAYS:
The following code implements an abstraction for debugging overlay sections.
struct obj_section *sec, *sec2;
if (!overlay_debugging)
- error (_("\
-Overlay debugging not enabled. Use either the 'overlay auto' or\n\
-the 'overlay manual' command."));
+ error (_("Overlay debugging not enabled. Use "
+ "either the 'overlay auto' or\n"
+ "the 'overlay manual' command."));
if (args == 0 || *args == 0)
error (_("Argument required: name of an overlay section"));
struct obj_section *sec;
if (!overlay_debugging)
- error (_("\
-Overlay debugging not enabled. Use either the 'overlay auto' or\n\
-the 'overlay manual' command."));
+ error (_("Overlay debugging not enabled. "
+ "Use either the 'overlay auto' or\n"
+ "the 'overlay manual' command."));
if (args == 0 || *args == 0)
error (_("Argument required: name of an overlay section"));
/* Cached, dynamically allocated copies of the target data structures: */
static unsigned (*cache_ovly_table)[4] = 0;
-#if 0
-static unsigned (*cache_ovly_region_table)[3] = 0;
-#endif
static unsigned cache_novlys = 0;
-#if 0
-static unsigned cache_novly_regions = 0;
-#endif
static CORE_ADDR cache_ovly_table_base = 0;
-#if 0
-static CORE_ADDR cache_ovly_region_table_base = 0;
-#endif
enum ovly_index
{
VMA, SIZE, LMA, MAPPED
cache_ovly_table_base = 0;
}
-#if 0
-/* Throw away the cached copy of _ovly_region_table */
-static void
-simple_free_overlay_region_table (void)
-{
- if (cache_ovly_region_table)
- xfree (cache_ovly_region_table);
- cache_novly_regions = 0;
- cache_ovly_region_table = NULL;
- cache_ovly_region_table_base = 0;
-}
-#endif
-
/* 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
return 1; /* SUCCESS */
}
-#if 0
-/* Find and grab a copy of the target _ovly_region_table
- (and _novly_regions, which is needed for the table's size) */
-static int
-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)
- 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)
- {
- msym = lookup_minimal_symbol ("_ovly_region_table", NULL, NULL);
- if (msym != 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,
- word_size, byte_order);
- }
- else
- return 0; /* failure */
- }
- else
- return 0; /* failure */
- return 1; /* SUCCESS */
-}
-#endif
-
/* Function: simple_overlay_update_1
A helper function for simple_overlay_update. Assuming a cached copy
of _ovly_table exists, look through it to find an entry whose vma,
if (cache_ovly_table != NULL)
/* Does its cached location match what's currently in the symtab? */
if (cache_ovly_table_base ==
- SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table", NULL, NULL)))
+ SYMBOL_VALUE_ADDRESS (lookup_minimal_symbol ("_ovly_table",
+ NULL, NULL)))
/* Then go ahead and try to look up this single section in the cache */
if (simple_overlay_update_1 (osect))
/* Found it! We're done. */
sectp->output_offset = 0;
}
+/* Default implementation for sym_relocate. */
+
+
+bfd_byte *
+default_symfile_relocate (struct objfile *objfile, asection *sectp,
+ bfd_byte *buf)
+{
+ bfd *abfd = objfile->obfd;
+
+ /* We're only interested in sections with relocation
+ information. */
+ if ((sectp->flags & SEC_RELOC) == 0)
+ return NULL;
+
+ /* We will handle section offsets properly elsewhere, so relocate as if
+ all sections begin at 0. */
+ bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL);
+
+ return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
+}
+
/* Relocate the contents of a debug section SECTP in ABFD. The
contents are stored in BUF if it is non-NULL, or returned in a
malloc'd buffer otherwise.
debug section. */
bfd_byte *
-symfile_relocate_debug_section (bfd *abfd, asection *sectp, bfd_byte *buf)
+symfile_relocate_debug_section (struct objfile *objfile,
+ asection *sectp, bfd_byte *buf)
{
- /* We're only interested in sections with relocation
- information. */
- if ((sectp->flags & SEC_RELOC) == 0)
- return NULL;
+ gdb_assert (objfile->sf->sym_relocate);
- /* We will handle section offsets properly elsewhere, so relocate as if
- all sections begin at 0. */
- bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL);
-
- return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
+ return (*objfile->sf->sym_relocate) (objfile, sectp, buf);
}
struct symfile_segment_data *
get_symfile_segment_data (bfd *abfd)
{
- struct sym_fns *sf = find_sym_fns (abfd);
+ const struct sym_fns *sf = find_sym_fns (abfd);
if (sf == NULL)
return NULL;
/* It doesn't make sense to call this function unless you have some
segment base addresses. */
- gdb_assert (segment_bases > 0);
+ gdb_assert (num_segment_bases > 0);
/* If we do not have segment mappings for the object file, we
can not relocate it by segments. */
for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
{
- CORE_ADDR vma;
int which = data->segment_info[i];
if (which == 1)
c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\
Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
-Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
-ADDR is the starting address of the file's text.\n\
+Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR>\
+ ...]\nADDR is the starting address of the file's text.\n\
The optional arguments are section-name section-address pairs and\n\
should be specified if the data and bss segments are not contiguous\n\
with the text. SECT is a section name to be loaded at SECT_ADDR."),
projects / deliverable / binutils-gdb.git / blobdiff