/* 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, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
#include "bcache.h"
#include "hashtab.h"
#include "readline/readline.h"
-#include "gdb_assert.h"
#include "block.h"
#include "observer.h"
#include "exec.h"
#include "elf-bfd.h"
#include "solib.h"
#include "remote.h"
+#include "stack.h"
+#include "gdb_bfd.h"
+#include "cli/cli-utils.h"
#include <sys/types.h>
#include <fcntl.h>
-#include "gdb_string.h"
-#include "gdb_stat.h"
+#include <sys/stat.h>
#include <ctype.h>
-#include <time.h>
-#include <sys/time.h>
+#include <chrono>
#include "psymtab.h"
/* Global variables owned by this file. */
int readnow_symbol_files; /* Read full symbols immediately. */
-/* External variables and functions referenced. */
-
-extern void report_transfer_performance (unsigned long, time_t, time_t);
-
/* Functions this file defines. */
static void load_command (char *, int);
-static void symbol_file_add_main_1 (char *args, int from_tty, int flags);
-
-static void add_symbol_file_command (char *, int);
-
-bfd *symfile_bfd_open (char *);
-
-int get_section_index (struct objfile *, char *);
+static void symbol_file_add_main_1 (const char *args, symfile_add_flags add_flags,
+ objfile_flags flags);
static const struct sym_fns *find_sym_fns (bfd *);
-static void decrement_reading_symtab (void *);
-
static void overlay_invalidate_all (void);
-void list_overlays_command (char *, int);
-
-void map_overlay_command (char *, int);
-
-void unmap_overlay_command (char *, int);
-
-static void overlay_auto_command (char *, int);
-
-static void overlay_manual_command (char *, int);
-
-static void overlay_off_command (char *, int);
-
-static void overlay_load_command (char *, int);
-
static void overlay_command (char *, int);
static void simple_free_overlay_table (void);
static int simple_overlay_update_1 (struct obj_section *);
-static void add_filename_language (char *ext, enum language lang);
-
static void info_ext_lang_command (char *args, int from_tty);
-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
calls add_symtab_fns() to register information on each format it is
prepared to read. */
-typedef const struct sym_fns *sym_fns_ptr;
-DEF_VEC_P (sym_fns_ptr);
+typedef struct
+{
+ /* BFD flavour that we handle. */
+ enum bfd_flavour sym_flavour;
-static VEC (sym_fns_ptr) *symtab_fns = NULL;
+ /* The "vtable" of symbol functions. */
+ const struct sym_fns *sym_fns;
+} registered_sym_fns;
-/* Flag for whether user will be reloading symbols multiple times.
- Defaults to ON for VxWorks, otherwise OFF. */
+DEF_VEC_O (registered_sym_fns);
-#ifdef SYMBOL_RELOADING_DEFAULT
-int symbol_reloading = SYMBOL_RELOADING_DEFAULT;
-#else
-int symbol_reloading = 0;
-#endif
-static void
-show_symbol_reloading (struct ui_file *file, int from_tty,
- struct cmd_list_element *c, const char *value)
+static VEC (registered_sym_fns) *symtab_fns = NULL;
+
+/* Values for "set print symbol-loading". */
+
+const char print_symbol_loading_off[] = "off";
+const char print_symbol_loading_brief[] = "brief";
+const char print_symbol_loading_full[] = "full";
+static const char *print_symbol_loading_enums[] =
{
- fprintf_filtered (file, _("Dynamic symbol table reloading "
- "multiple times in one run is %s.\n"),
- value);
-}
+ print_symbol_loading_off,
+ print_symbol_loading_brief,
+ print_symbol_loading_full,
+ NULL
+};
+static const char *print_symbol_loading = print_symbol_loading_full;
/* If non-zero, shared library symbols will be added automatically
when the inferior is created, new libraries are loaded, or when
int auto_solib_add = 1;
\f
-/* 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. */
-
-char *
-obsavestring (const char *ptr, int size, struct obstack *obstackp)
-{
- char *p = (char *) obstack_alloc (obstackp, size + 1);
- /* Open-coded memcpy--saves function call time. These strings are usually
- short. FIXME: Is this really still true with a compiler that can
- inline memcpy? */
- {
- const char *p1 = ptr;
- char *p2 = p;
- const char *end = ptr + size;
-
- while (p1 != end)
- *p2++ = *p1++;
- }
- p[size] = 0;
- return p;
-}
+/* Return non-zero if symbol-loading messages should be printed.
+ FROM_TTY is the standard from_tty argument to gdb commands.
+ If EXEC is non-zero the messages are for the executable.
+ Otherwise, messages are for shared libraries.
+ If FULL is non-zero then the caller is printing a detailed message.
+ E.g., the message includes the shared library name.
+ Otherwise, the caller is printing a brief "summary" message. */
-/* 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, ...)
+int
+print_symbol_loading_p (int from_tty, int exec, int full)
{
- va_list ap;
+ if (!from_tty && !info_verbose)
+ return 0;
- va_start (ap, obstackp);
- for (;;)
+ if (exec)
{
- const char *s = va_arg (ap, const char *);
-
- if (s == NULL)
- break;
-
- obstack_grow_str (obstackp, s);
+ /* We don't check FULL for executables, there are few such
+ messages, therefore brief == full. */
+ return print_symbol_loading != print_symbol_loading_off;
}
- va_end (ap);
- obstack_1grow (obstackp, 0);
-
- return obstack_finish (obstackp);
+ if (full)
+ return print_symbol_loading == print_symbol_loading_full;
+ return print_symbol_loading == print_symbol_loading_brief;
}
/* True if we are reading a symbol table. */
int currently_reading_symtab = 0;
-static void
-decrement_reading_symtab (void *dummy)
-{
- currently_reading_symtab--;
-}
-
/* Increment currently_reading_symtab and return a cleanup that can be
used to decrement it. */
-struct cleanup *
+
+scoped_restore_tmpl<int>
increment_reading_symtab (void)
{
- ++currently_reading_symtab;
- return make_cleanup (decrement_reading_symtab, NULL);
+ gdb_assert (currently_reading_symtab >= 0);
+ return make_scoped_restore (¤tly_reading_symtab,
+ currently_reading_symtab + 1);
}
/* Remember the lowest-addressed loadable section we've seen.
*lowest = sect;
}
-/* Create a new section_addr_info, with room for NUM_SECTIONS. */
+/* Create a new section_addr_info, with room for NUM_SECTIONS. The
+ new object's 'num_sections' field is set to 0; it must be updated
+ by the caller. */
struct section_addr_info *
alloc_section_addr_info (size_t num_sections)
+ sizeof (struct other_sections) * (num_sections - 1));
sap = (struct section_addr_info *) xmalloc (size);
memset (sap, 0, size);
- sap->num_sections = num_sections;
return sap;
}
for (stp = start, oidx = 0; stp != end; stp++)
{
- if (bfd_get_section_flags (stp->bfd,
- stp->the_bfd_section) & (SEC_ALLOC | SEC_LOAD)
+ struct bfd_section *asect = stp->the_bfd_section;
+ bfd *abfd = asect->owner;
+
+ if (bfd_get_section_flags (abfd, asect) & (SEC_ALLOC | SEC_LOAD)
&& oidx < end - start)
{
sap->other[oidx].addr = stp->addr;
- sap->other[oidx].name
- = xstrdup (bfd_section_name (stp->bfd, stp->the_bfd_section));
- sap->other[oidx].sectindex = stp->the_bfd_section->index;
+ sap->other[oidx].name = xstrdup (bfd_section_name (abfd, asect));
+ sap->other[oidx].sectindex = gdb_bfd_section_index (abfd, asect);
oidx++;
}
}
+ sap->num_sections = oidx;
+
return sap;
}
{
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;
+ sap->other[i].sectindex = gdb_bfd_section_index (abfd, sec);
i++;
}
+
+ sap->num_sections = i;
+
return sap;
}
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++)
+ for (i = 0; i < sap->num_sections; i++)
{
int sectindex = sap->other[i].sectindex;
int idx;
for (idx = 0; idx < sap->num_sections; idx++)
- if (sap->other[idx].name)
- xfree (sap->other[idx].name);
+ xfree (sap->other[idx].name);
xfree (sap);
}
-
/* Initialize OBJFILE's sect_index_* members. */
+
static void
init_objfile_sect_indices (struct objfile *objfile)
{
static void
place_section (bfd *abfd, asection *sect, void *obj)
{
- struct place_section_arg *arg = obj;
+ struct place_section_arg *arg = (struct place_section_arg *) obj;
CORE_ADDR *offsets = arg->offsets->offsets, start_addr;
int done;
ULONGEST align = ((ULONGEST) 1) << bfd_get_section_alignment (abfd, sect);
return;
/* If the user specified an offset, honor it. */
- if (offsets[sect->index] != 0)
+ if (offsets[gdb_bfd_section_index (abfd, sect)] != 0)
return;
/* Otherwise, let's try to find a place for the section. */
}
while (!done);
- offsets[sect->index] = start_addr;
+ offsets[gdb_bfd_section_index (abfd, sect)] = start_addr;
arg->lowest = start_addr + bfd_get_section_size (sect);
}
void
relative_addr_info_to_section_offsets (struct section_offsets *section_offsets,
int num_sections,
- struct section_addr_info *addrs)
+ const struct section_addr_info *addrs)
{
int i;
memset (section_offsets, 0, SIZEOF_N_SECTION_OFFSETS (num_sections));
/* Now calculate offsets for section that were specified by the caller. */
- for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
+ for (i = 0; i < addrs->num_sections; i++)
{
- struct other_sections *osp;
+ const struct other_sections *osp;
osp = &addrs->other[i];
- if (osp->addr == 0)
+ if (osp->sectindex == -1)
continue;
/* Record all sections in offsets. */
{
const struct other_sections *a = *((struct other_sections **) ap);
const struct other_sections *b = *((struct other_sections **) bp);
- int retval, a_idx, b_idx;
+ int retval;
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;
+ return a->sectindex - b->sectindex;
}
/* Provide sorted array of pointers to sections of ADDRS. The array is
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 = XNEWVEC (struct other_sections *, addrs->num_sections + 1);
+ for (i = 0; i < addrs->num_sections; i++)
array[i] = &addrs->other[i];
array[i] = NULL;
/* 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);
+ addrs_to_abfd_addrs = XCNEWVEC (struct other_sections *, addrs->num_sections);
make_cleanup (xfree, addrs_to_abfd_addrs);
while (*addrs_sorted)
(the loadable section directly below it in memory).
this_offset = lower_offset = lower_addr - lower_orig_addr */
- for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
+ for (i = 0; i < addrs->num_sections; i++)
{
struct other_sections *sect = addrs_to_abfd_addrs[i];
bfd_get_filename (abfd));
addrs->other[i].addr = 0;
-
- /* SECTINDEX is invalid if ADDR is zero. */
+ addrs->other[i].sectindex = -1;
}
}
void
default_symfile_offsets (struct objfile *objfile,
- struct section_addr_info *addrs)
+ const struct section_addr_info *addrs)
{
- objfile->num_sections = bfd_count_sections (objfile->obfd);
+ objfile->num_sections = gdb_bfd_count_sections (objfile->obfd);
objfile->section_offsets = (struct section_offsets *)
obstack_alloc (&objfile->objfile_obstack,
SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
init_objfile_sect_indices (objfile);
}
-
/* 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.
low = bfd_get_section_vma (abfd, sect);
high = low + bfd_get_section_size (sect);
- data = XZALLOC (struct symfile_segment_data);
+ data = XCNEW (struct symfile_segment_data);
data->num_segments = 1;
- data->segment_bases = XCALLOC (1, CORE_ADDR);
- data->segment_sizes = XCALLOC (1, CORE_ADDR);
+ data->segment_bases = XCNEW (CORE_ADDR);
+ data->segment_sizes = XCNEW (CORE_ADDR);
num_sections = bfd_count_sections (abfd);
- data->segment_info = XCALLOC (num_sections, int);
+ data->segment_info = XCNEWVEC (int, num_sections);
for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
{
return data;
}
+/* This is a convenience function to call sym_read for OBJFILE and
+ possibly force the partial symbols to be read. */
+
+static void
+read_symbols (struct objfile *objfile, symfile_add_flags add_flags)
+{
+ (*objfile->sf->sym_read) (objfile, add_flags);
+ objfile->per_bfd->minsyms_read = true;
+
+ /* find_separate_debug_file_in_section should be called only if there is
+ single binary with no existing separate debug info file. */
+ if (!objfile_has_partial_symbols (objfile)
+ && objfile->separate_debug_objfile == NULL
+ && objfile->separate_debug_objfile_backlink == NULL)
+ {
+ gdb_bfd_ref_ptr abfd (find_separate_debug_file_in_section (objfile));
+
+ if (abfd != NULL)
+ {
+ /* find_separate_debug_file_in_section uses the same filename for the
+ virtual section-as-bfd like the bfd filename containing the
+ section. Therefore use also non-canonical name form for the same
+ file containing the section. */
+ symbol_file_add_separate (abfd.get (), objfile->original_name,
+ add_flags, objfile);
+ }
+ }
+ if ((add_flags & SYMFILE_NO_READ) == 0)
+ require_partial_symbols (objfile, 0);
+}
+
+/* Initialize entry point information for this objfile. */
+
+static void
+init_entry_point_info (struct objfile *objfile)
+{
+ struct entry_info *ei = &objfile->per_bfd->ei;
+
+ if (ei->initialized)
+ return;
+ ei->initialized = 1;
+
+ /* Save startup file's range of PC addresses to help blockframe.c
+ decide where the bottom of the stack is. */
+
+ if (bfd_get_file_flags (objfile->obfd) & EXEC_P)
+ {
+ /* Executable file -- record its entry point so we'll recognize
+ the startup file because it contains the entry point. */
+ ei->entry_point = bfd_get_start_address (objfile->obfd);
+ ei->entry_point_p = 1;
+ }
+ else if (bfd_get_file_flags (objfile->obfd) & DYNAMIC
+ && bfd_get_start_address (objfile->obfd) != 0)
+ {
+ /* Some shared libraries may have entry points set and be
+ runnable. There's no clear way to indicate this, so just check
+ for values other than zero. */
+ ei->entry_point = bfd_get_start_address (objfile->obfd);
+ ei->entry_point_p = 1;
+ }
+ else
+ {
+ /* Examination of non-executable.o files. Short-circuit this stuff. */
+ ei->entry_point_p = 0;
+ }
+
+ if (ei->entry_point_p)
+ {
+ struct obj_section *osect;
+ CORE_ADDR entry_point = ei->entry_point;
+ int found;
+
+ /* Make certain that the address points at real code, and not a
+ function descriptor. */
+ entry_point
+ = gdbarch_convert_from_func_ptr_addr (get_objfile_arch (objfile),
+ entry_point,
+ ¤t_target);
+
+ /* Remove any ISA markers, so that this matches entries in the
+ symbol table. */
+ ei->entry_point
+ = gdbarch_addr_bits_remove (get_objfile_arch (objfile), entry_point);
+
+ found = 0;
+ ALL_OBJFILE_OSECTIONS (objfile, osect)
+ {
+ struct bfd_section *sect = osect->the_bfd_section;
+
+ if (entry_point >= bfd_get_section_vma (objfile->obfd, sect)
+ && entry_point < (bfd_get_section_vma (objfile->obfd, sect)
+ + bfd_get_section_size (sect)))
+ {
+ ei->the_bfd_section_index
+ = gdb_bfd_section_index (objfile->obfd, sect);
+ found = 1;
+ break;
+ }
+ }
+
+ if (!found)
+ ei->the_bfd_section_index = SECT_OFF_TEXT (objfile);
+ }
+}
+
/* Process a symbol file, as either the main file or as a dynamically
loaded file.
+ This function does not set the OBJFILE's entry-point info.
+
OBJFILE is where the symbols are to be read from.
ADDRS is the list of section load addresses. If the user has given
into an offset from the section VMA's as it appears in the object
file, and then call the file's sym_offsets function to convert this
into a format-specific offset table --- a `struct section_offsets'.
- If ADDRS is non-zero, OFFSETS must be zero.
-
- OFFSETS is a table of section offsets already in the right
- format-specific representation. NUM_OFFSETS is the number of
- elements present in OFFSETS->offsets. If OFFSETS is non-zero, we
- assume this is the proper table the call to sym_offsets described
- above would produce. Instead of calling sym_offsets, we just dump
- it right into objfile->section_offsets. (When we're re-reading
- symbols from an objfile, we don't have the original load address
- list any more; all we have is the section offset table.) If
- OFFSETS is non-zero, ADDRS must be zero.
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 add_flags)
+static void
+syms_from_objfile_1 (struct objfile *objfile,
+ struct section_addr_info *addrs,
+ symfile_add_flags add_flags)
{
struct section_addr_info *local_addr = NULL;
struct cleanup *old_chain;
const int mainline = add_flags & SYMFILE_MAINLINE;
- gdb_assert (! (addrs && offsets));
-
- init_entry_point_info (objfile);
- objfile->sf = find_sym_fns (objfile->obfd);
+ objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd));
if (objfile->sf == NULL)
- return; /* No symbols. */
+ {
+ /* No symbols to load, but we still need to make sure
+ that the section_offsets table is allocated. */
+ int num_sections = gdb_bfd_count_sections (objfile->obfd);
+ size_t size = SIZEOF_N_SECTION_OFFSETS (num_sections);
+
+ objfile->num_sections = num_sections;
+ objfile->section_offsets
+ = (struct section_offsets *) obstack_alloc (&objfile->objfile_obstack,
+ size);
+ memset (objfile->section_offsets, 0, size);
+ return;
+ }
/* Make sure that partially constructed symbol tables will be cleaned up
if an error occurs during symbol reading. */
old_chain = make_cleanup_free_objfile (objfile);
- /* If ADDRS and OFFSETS are both NULL, put together a dummy address
- list. We now establish the convention that an addr of zero means
+ /* If ADDRS is NULL, put together a dummy address list.
+ We now establish the convention that an addr of zero means
no load address was specified. */
- if (! addrs && ! offsets)
+ if (! addrs)
{
- local_addr
- = alloc_section_addr_info (bfd_count_sections (objfile->obfd));
+ local_addr = alloc_section_addr_info (1);
make_cleanup (xfree, local_addr);
addrs = local_addr;
}
- /* Now either addrs or offsets is non-zero. */
-
if (mainline)
{
/* We will modify the main symbol table, make sure that all its users
We no longer warn if the lowest section is not a text segment (as
happens for the PA64 port. */
- if (addrs && addrs->other[0].name)
+ if (addrs->num_sections > 0)
addr_info_make_relative (addrs, objfile->obfd);
/* Initialize symbol reading routines for this objfile, allow complaints to
(*objfile->sf->sym_init) (objfile);
clear_complaints (&symfile_complaints, 1, add_flags & SYMFILE_VERBOSE);
- if (addrs)
- (*objfile->sf->sym_offsets) (objfile, addrs);
- else
- {
- size_t size = SIZEOF_N_SECTION_OFFSETS (num_offsets);
-
- /* Just copy in the offset table directly as given to us. */
- objfile->num_sections = num_offsets;
- objfile->section_offsets
- = ((struct section_offsets *)
- obstack_alloc (&objfile->objfile_obstack, size));
- memcpy (objfile->section_offsets, offsets, size);
+ (*objfile->sf->sym_offsets) (objfile, addrs);
- init_objfile_sect_indices (objfile);
- }
-
- (*objfile->sf->sym_read) (objfile, add_flags);
+ read_symbols (objfile, add_flags);
/* Discard cleanups as symbol reading was successful. */
xfree (local_addr);
}
+/* Same as syms_from_objfile_1, but also initializes the objfile
+ entry-point info. */
+
+static void
+syms_from_objfile (struct objfile *objfile,
+ struct section_addr_info *addrs,
+ symfile_add_flags add_flags)
+{
+ syms_from_objfile_1 (objfile, addrs, add_flags);
+ init_entry_point_info (objfile);
+}
+
/* Perform required actions after either reading in the initial
symbols for a new objfile, or mapping in the symbols from a reusable
objfile. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
-void
-new_symfile_objfile (struct objfile *objfile, int add_flags)
+static void
+finish_new_objfile (struct objfile *objfile, symfile_add_flags 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
loaded file.
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.
+ A new reference is acquired by this function.
+
+ For NAME description see allocate_objfile's definition.
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 as described for syms_from_objfile_1, above.
ADDRS is ignored when SYMFILE_MAINLINE bit is set in ADD_FLAGS.
+ PARENT is the original objfile if ABFD is a separate debug info file.
+ Otherwise PARENT is NULL.
+
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 add_flags,
- struct section_addr_info *addrs,
- struct section_offsets *offsets,
- int num_offsets,
- int flags)
+symbol_file_add_with_addrs (bfd *abfd, const char *name,
+ symfile_add_flags add_flags,
+ struct section_addr_info *addrs,
+ objfile_flags flags, struct objfile *parent)
{
struct objfile *objfile;
- struct cleanup *my_cleanups;
- const char *name = bfd_get_filename (abfd);
const int from_tty = add_flags & SYMFILE_VERBOSE;
+ const int mainline = add_flags & SYMFILE_MAINLINE;
+ const int should_print = (print_symbol_loading_p (from_tty, mainline, 1)
+ && (readnow_symbol_files
+ || (add_flags & SYMFILE_NO_READ) == 0));
if (readnow_symbol_files)
- flags |= OBJF_READNOW;
-
- my_cleanups = make_cleanup_bfd_close (abfd);
+ {
+ flags |= OBJF_READNOW;
+ add_flags &= ~SYMFILE_NO_READ;
+ }
/* Give user a chance to burp if we'd be
interactively wiping out any existing symbols. */
if ((have_full_symbols () || have_partial_symbols ())
- && (add_flags & SYMFILE_MAINLINE)
+ && mainline
&& from_tty
&& !query (_("Load new symbol table from \"%s\"? "), name))
error (_("Not confirmed."));
- objfile = allocate_objfile (abfd, flags);
- discard_cleanups (my_cleanups);
+ if (mainline)
+ flags |= OBJF_MAINLINE;
+ objfile = allocate_objfile (abfd, name, flags);
+
+ if (parent)
+ add_separate_debug_objfile (objfile, parent);
/* We either created a new mapped symbol table, mapped an existing
symbol table file which has not had initial symbol reading
performed, or need to read an unmapped symbol table. */
- if (from_tty || info_verbose)
+ if (should_print)
{
if (deprecated_pre_add_symbol_hook)
deprecated_pre_add_symbol_hook (name);
gdb_flush (gdb_stdout);
}
}
- syms_from_objfile (objfile, addrs, offsets, num_offsets,
- add_flags);
+ syms_from_objfile (objfile, addrs, 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))
{
- if (from_tty || info_verbose)
+ if (should_print)
{
printf_unfiltered (_("expanding to full symbols..."));
wrap_here ("");
objfile->sf->qf->expand_all_symtabs (objfile);
}
- if ((from_tty || info_verbose)
- && !objfile_has_symbols (objfile))
+ if (should_print && !objfile_has_symbols (objfile))
{
wrap_here ("");
printf_unfiltered (_("(no debugging symbols found)..."));
wrap_here ("");
}
- if (from_tty || info_verbose)
+ if (should_print)
{
if (deprecated_post_add_symbol_hook)
deprecated_post_add_symbol_hook ();
time. */
gdb_flush (gdb_stdout);
- do_cleanups (my_cleanups);
-
if (objfile->sf == NULL)
{
observer_notify_new_objfile (objfile);
return objfile; /* No symbols. */
}
- new_symfile_objfile (objfile, add_flags);
+ finish_new_objfile (objfile, add_flags);
observer_notify_new_objfile (objfile);
return (objfile);
}
-/* Add BFD as a separate debug file for OBJFILE. */
+/* Add BFD as a separate debug file for OBJFILE. For NAME description
+ see allocate_objfile's definition. */
void
-symbol_file_add_separate (bfd *bfd, int symfile_flags, struct objfile *objfile)
+symbol_file_add_separate (bfd *bfd, const char *name,
+ symfile_add_flags symfile_flags,
+ struct objfile *objfile)
{
- struct objfile *new_objfile;
struct section_addr_info *sap;
struct cleanup *my_cleanup;
sap = build_section_addr_info_from_objfile (objfile);
my_cleanup = make_cleanup_free_section_addr_info (sap);
- new_objfile = symbol_file_add_with_addrs_or_offsets
- (bfd, symfile_flags,
- sap, NULL, 0,
+ symbol_file_add_with_addrs
+ (bfd, name, symfile_flags, sap,
objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW
- | OBJF_USERLOADED));
+ | OBJF_USERLOADED),
+ objfile);
do_cleanups (my_cleanup);
-
- add_separate_debug_objfile (new_objfile, objfile);
}
/* Process the symbol file ABFD, as either the main file or as a
dynamically loaded file.
+ See symbol_file_add_with_addrs's comments for details. */
- See symbol_file_add_with_addrs_or_offsets's comments for
- details. */
struct objfile *
-symbol_file_add_from_bfd (bfd *abfd, int add_flags,
+symbol_file_add_from_bfd (bfd *abfd, const char *name,
+ symfile_add_flags add_flags,
struct section_addr_info *addrs,
- int flags)
+ objfile_flags flags, struct objfile *parent)
{
- return symbol_file_add_with_addrs_or_offsets (abfd, add_flags, addrs, 0, 0,
- flags);
+ return symbol_file_add_with_addrs (abfd, name, add_flags, addrs, flags,
+ parent);
}
-
/* Process a symbol file, as either the main file or as a dynamically
- loaded file. See symbol_file_add_with_addrs_or_offsets's comments
- for details. */
+ loaded file. See symbol_file_add_with_addrs's comments for details. */
+
struct objfile *
-symbol_file_add (char *name, int add_flags, struct section_addr_info *addrs,
- int flags)
+symbol_file_add (const char *name, symfile_add_flags add_flags,
+ struct section_addr_info *addrs, objfile_flags flags)
{
- return symbol_file_add_from_bfd (symfile_bfd_open (name), add_flags, addrs,
- flags);
-}
+ gdb_bfd_ref_ptr bfd (symfile_bfd_open (name));
+ return symbol_file_add_from_bfd (bfd.get (), name, add_flags, addrs,
+ flags, NULL);
+}
/* Call symbol_file_add() with default values and update whatever is
affected by the loading of a new main().
command itself. */
void
-symbol_file_add_main (char *args, int from_tty)
+symbol_file_add_main (const char *args, symfile_add_flags add_flags)
{
- symbol_file_add_main_1 (args, from_tty, 0);
+ symbol_file_add_main_1 (args, add_flags, 0);
}
static void
-symbol_file_add_main_1 (char *args, int from_tty, int flags)
+symbol_file_add_main_1 (const char *args, symfile_add_flags add_flags,
+ objfile_flags flags)
{
- const int add_flags = SYMFILE_MAINLINE | (from_tty ? SYMFILE_VERBOSE : 0);
+ add_flags |= current_inferior ()->symfile_flags | SYMFILE_MAINLINE;
+
symbol_file_add (args, add_flags, NULL, flags);
/* Getting new symbols may change our opinion about
what is frameless. */
reinit_frame_cache ();
- set_initial_language ();
+ if ((add_flags & SYMFILE_NO_READ) == 0)
+ set_initial_language ();
}
void
&& from_tty
&& (symfile_objfile
? !query (_("Discard symbol table from `%s'? "),
- symfile_objfile->name)
+ objfile_name (symfile_objfile))
: !query (_("Discard symbol table? "))))
error (_("Not confirmed."));
printf_unfiltered (_("No symbol file now.\n"));
}
-static char *
-get_debug_link_info (struct objfile *objfile, unsigned long *crc32_out)
-{
- asection *sect;
- bfd_size_type debuglink_size;
- unsigned long crc32;
- char *contents;
- int crc_offset;
-
- sect = bfd_get_section_by_name (objfile->obfd, ".gnu_debuglink");
+/* See symfile.h. */
- if (sect == NULL)
- return NULL;
-
- debuglink_size = bfd_section_size (objfile->obfd, sect);
-
- contents = xmalloc (debuglink_size);
- bfd_get_section_contents (objfile->obfd, sect, contents,
- (file_ptr)0, (bfd_size_type)debuglink_size);
-
- /* Crc value is stored after the filename, aligned up to 4 bytes. */
- crc_offset = strlen (contents) + 1;
- crc_offset = (crc_offset + 3) & ~3;
-
- crc32 = bfd_get_32 (objfile->obfd, (bfd_byte *) (contents + crc_offset));
-
- *crc32_out = crc32;
- return contents;
-}
+int separate_debug_file_debug = 0;
static int
separate_debug_file_exists (const char *name, unsigned long crc,
struct objfile *parent_objfile)
{
- unsigned long file_crc = 0;
- bfd *abfd;
- gdb_byte buffer[8*1024];
- int count;
+ unsigned long file_crc;
+ int file_crc_p;
struct stat parent_stat, abfd_stat;
+ int verified_as_different;
/* Find a separate debug info file as if symbols would be present in
PARENT_OBJFILE itself this function would not be called. .gnu_debuglink
".debug" suffix as "/usr/lib/debug/path/to/file" is a separate tree where
the separate debug infos with the same basename can exist. */
- if (strcmp (name, parent_objfile->name) == 0)
+ if (filename_cmp (name, objfile_name (parent_objfile)) == 0)
return 0;
- abfd = bfd_open_maybe_remote (name);
+ if (separate_debug_file_debug)
+ printf_unfiltered (_(" Trying %s\n"), name);
- if (!abfd)
+ gdb_bfd_ref_ptr abfd (gdb_bfd_open (name, gnutarget, -1));
+
+ if (abfd == NULL)
return 0;
- /* Verify symlinks were not the cause of strcmp name difference above.
+ /* Verify symlinks were not the cause of filename_cmp name difference above.
Some operating systems, e.g. Windows, do not provide a meaningful
st_ino; they always set it to zero. (Windows does provide a
- meaningful st_dev.) Do not indicate a duplicate library in that
- case. While there is no guarantee that a system that provides
- meaningful inode numbers will never set st_ino to zero, this is
- merely an optimization, so we do not need to worry about false
- negatives. */
-
- if (bfd_stat (abfd, &abfd_stat) == 0
- && bfd_stat (parent_objfile->obfd, &parent_stat) == 0
- && abfd_stat.st_dev == parent_stat.st_dev
- && abfd_stat.st_ino == parent_stat.st_ino
- && abfd_stat.st_ino != 0)
- {
- bfd_close (abfd);
- return 0;
+ meaningful st_dev.) Files accessed from gdbservers that do not
+ support the vFile:fstat packet will also have st_ino set to zero.
+ Do not indicate a duplicate library in either case. While there
+ is no guarantee that a system that provides meaningful inode
+ numbers will never set st_ino to zero, this is merely an
+ optimization, so we do not need to worry about false negatives. */
+
+ if (bfd_stat (abfd.get (), &abfd_stat) == 0
+ && abfd_stat.st_ino != 0
+ && bfd_stat (parent_objfile->obfd, &parent_stat) == 0)
+ {
+ if (abfd_stat.st_dev == parent_stat.st_dev
+ && abfd_stat.st_ino == parent_stat.st_ino)
+ return 0;
+ verified_as_different = 1;
}
+ else
+ verified_as_different = 0;
- while ((count = bfd_bread (buffer, sizeof (buffer), abfd)) > 0)
- file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
+ file_crc_p = gdb_bfd_crc (abfd.get (), &file_crc);
- bfd_close (abfd);
+ if (!file_crc_p)
+ return 0;
if (crc != file_crc)
{
- warning (_("the debug information found in \"%s\""
- " does not match \"%s\" (CRC mismatch).\n"),
- name, parent_objfile->name);
+ unsigned long parent_crc;
+
+ /* If the files could not be verified as different with
+ bfd_stat then we need to calculate the parent's CRC
+ to verify whether the files are different or not. */
+
+ if (!verified_as_different)
+ {
+ if (!gdb_bfd_crc (parent_objfile->obfd, &parent_crc))
+ return 0;
+ }
+
+ if (verified_as_different || parent_crc != file_crc)
+ warning (_("the debug information found in \"%s\""
+ " does not match \"%s\" (CRC mismatch).\n"),
+ name, objfile_name (parent_objfile));
+
return 0;
}
#define DEBUG_SUBDIRECTORY ".debug"
#endif
-char *
-find_separate_debug_file_by_debuglink (struct objfile *objfile)
+/* Find a separate debuginfo file for OBJFILE, using DIR as the directory
+ where the original file resides (may not be the same as
+ dirname(objfile->name) due to symlinks), and DEBUGLINK as the file we are
+ looking for. CANON_DIR is the "realpath" form of DIR.
+ DIR must contain a trailing '/'.
+ Returns the path of the file with separate debug info, of NULL. */
+
+static char *
+find_separate_debug_file (const char *dir,
+ const char *canon_dir,
+ const char *debuglink,
+ unsigned long crc32, struct objfile *objfile)
{
- char *basename, *debugdir;
- char *dir = NULL;
- char *debugfile = NULL;
- char *canon_name = NULL;
- unsigned long crc32;
+ char *debugdir;
+ char *debugfile;
int i;
+ VEC (char_ptr) *debugdir_vec;
+ struct cleanup *back_to;
+ int ix;
- 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. */
- goto cleanup_return_debugfile;
-
- dir = xstrdup (objfile->name);
-
- /* Strip off the final filename part, leaving the directory name,
- 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;
- }
- /* If I is -1 then no directory is present there and DIR will be "". */
- dir[i+1] = '\0';
+ if (separate_debug_file_debug)
+ printf_unfiltered (_("\nLooking for separate debug info (debug link) for "
+ "%s\n"), objfile_name (objfile));
- /* Set I to max (strlen (canon_name), strlen (dir)). */
- canon_name = lrealpath (dir);
+ /* Set I to std::max (strlen (canon_dir), strlen (dir)). */
i = strlen (dir);
- if (canon_name && strlen (canon_name) > i)
- i = strlen (canon_name);
+ if (canon_dir != NULL && strlen (canon_dir) > i)
+ i = strlen (canon_dir);
- debugfile = xmalloc (strlen (debug_file_directory) + 1
- + i
- + strlen (DEBUG_SUBDIRECTORY)
- + strlen ("/")
- + strlen (basename)
- + 1);
+ debugfile
+ = (char *) xmalloc (strlen (debug_file_directory) + 1
+ + i
+ + strlen (DEBUG_SUBDIRECTORY)
+ + strlen ("/")
+ + strlen (debuglink)
+ + 1);
/* First try in the same directory as the original file. */
strcpy (debugfile, dir);
- strcat (debugfile, basename);
+ strcat (debugfile, debuglink);
if (separate_debug_file_exists (debugfile, crc32, objfile))
- goto cleanup_return_debugfile;
+ return debugfile;
/* Then try in the subdirectory named DEBUG_SUBDIRECTORY. */
strcpy (debugfile, dir);
strcat (debugfile, DEBUG_SUBDIRECTORY);
strcat (debugfile, "/");
- strcat (debugfile, basename);
+ strcat (debugfile, debuglink);
if (separate_debug_file_exists (debugfile, crc32, objfile))
- goto cleanup_return_debugfile;
+ return debugfile;
/* Then try in the global debugfile directories.
-
+
Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
cause "/..." lookups. */
- debugdir = debug_file_directory;
- do
- {
- char *debugdir_end;
-
- while (*debugdir == DIRNAME_SEPARATOR)
- debugdir++;
-
- debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
- if (debugdir_end == NULL)
- debugdir_end = &debugdir[strlen (debugdir)];
+ debugdir_vec = dirnames_to_char_ptr_vec (debug_file_directory);
+ back_to = make_cleanup_free_char_ptr_vec (debugdir_vec);
- memcpy (debugfile, debugdir, debugdir_end - debugdir);
- debugfile[debugdir_end - debugdir] = 0;
+ for (ix = 0; VEC_iterate (char_ptr, debugdir_vec, ix, debugdir); ++ix)
+ {
+ strcpy (debugfile, debugdir);
strcat (debugfile, "/");
strcat (debugfile, dir);
- strcat (debugfile, basename);
+ strcat (debugfile, debuglink);
if (separate_debug_file_exists (debugfile, crc32, objfile))
- goto cleanup_return_debugfile;
+ {
+ do_cleanups (back_to);
+ return debugfile;
+ }
/* If the file is in the sysroot, try using its base path in the
global debugfile directory. */
- if (canon_name
- && strncmp (canon_name, gdb_sysroot, strlen (gdb_sysroot)) == 0
- && IS_DIR_SEPARATOR (canon_name[strlen (gdb_sysroot)]))
+ if (canon_dir != NULL
+ && filename_ncmp (canon_dir, gdb_sysroot,
+ strlen (gdb_sysroot)) == 0
+ && IS_DIR_SEPARATOR (canon_dir[strlen (gdb_sysroot)]))
{
- memcpy (debugfile, debugdir, debugdir_end - debugdir);
- debugfile[debugdir_end - debugdir] = 0;
- strcat (debugfile, canon_name + strlen (gdb_sysroot));
+ strcpy (debugfile, debugdir);
+ strcat (debugfile, canon_dir + strlen (gdb_sysroot));
strcat (debugfile, "/");
- strcat (debugfile, basename);
+ strcat (debugfile, debuglink);
if (separate_debug_file_exists (debugfile, crc32, objfile))
- goto cleanup_return_debugfile;
+ {
+ do_cleanups (back_to);
+ return debugfile;
+ }
}
-
- debugdir = debugdir_end;
}
- while (*debugdir != 0);
-
+
+ do_cleanups (back_to);
xfree (debugfile);
- debugfile = NULL;
+ return NULL;
+}
-cleanup_return_debugfile:
- xfree (canon_name);
- xfree (basename);
- xfree (dir);
- return debugfile;
+/* Modify PATH to contain only "[/]directory/" part of PATH.
+ If there were no directory separators in PATH, PATH will be empty
+ string on return. */
+
+static void
+terminate_after_last_dir_separator (char *path)
+{
+ int i;
+
+ /* Strip off the final filename part, leaving the directory name,
+ followed by a slash. The directory can be relative or absolute. */
+ for (i = strlen(path) - 1; i >= 0; i--)
+ if (IS_DIR_SEPARATOR (path[i]))
+ break;
+
+ /* If I is -1 then no directory is present there and DIR will be "". */
+ path[i + 1] = '\0';
}
+/* Find separate debuginfo for OBJFILE (using .gnu_debuglink section).
+ Returns pathname, or NULL. */
+
+char *
+find_separate_debug_file_by_debuglink (struct objfile *objfile)
+{
+ char *debuglink;
+ char *dir, *canon_dir;
+ char *debugfile;
+ unsigned long crc32;
+ struct cleanup *cleanups;
+
+ debuglink = bfd_get_debug_link_info (objfile->obfd, &crc32);
+
+ if (debuglink == NULL)
+ {
+ /* There's no separate debug info, hence there's no way we could
+ load it => no warning. */
+ return NULL;
+ }
+
+ cleanups = make_cleanup (xfree, debuglink);
+ dir = xstrdup (objfile_name (objfile));
+ make_cleanup (xfree, dir);
+ terminate_after_last_dir_separator (dir);
+ canon_dir = lrealpath (dir);
+
+ debugfile = find_separate_debug_file (dir, canon_dir, debuglink,
+ crc32, objfile);
+ xfree (canon_dir);
+
+ if (debugfile == NULL)
+ {
+ /* For PR gdb/9538, try again with realpath (if different from the
+ original). */
+
+ struct stat st_buf;
+
+ if (lstat (objfile_name (objfile), &st_buf) == 0
+ && S_ISLNK (st_buf.st_mode))
+ {
+ char *symlink_dir;
+
+ symlink_dir = lrealpath (objfile_name (objfile));
+ if (symlink_dir != NULL)
+ {
+ make_cleanup (xfree, symlink_dir);
+ terminate_after_last_dir_separator (symlink_dir);
+ if (strcmp (dir, symlink_dir) != 0)
+ {
+ /* Different directory, so try using it. */
+ debugfile = find_separate_debug_file (symlink_dir,
+ symlink_dir,
+ debuglink,
+ crc32,
+ objfile);
+ }
+ }
+ }
+ }
+
+ do_cleanups (cleanups);
+ return debugfile;
+}
/* This is the symbol-file command. Read the file, analyze its
symbols, and add a struct symtab to a symtab list. The syntax of
conventions (because it is confusing and inconvenient). */
void
-symbol_file_command (char *args, int from_tty)
+symbol_file_command (const char *args, int from_tty)
{
dont_repeat ();
}
else
{
- char **argv = gdb_buildargv (args);
- int flags = OBJF_USERLOADED;
+ objfile_flags flags = OBJF_USERLOADED;
+ symfile_add_flags add_flags = 0;
struct cleanup *cleanups;
char *name = NULL;
- cleanups = make_cleanup_freeargv (argv);
- while (*argv != NULL)
+ if (from_tty)
+ add_flags |= SYMFILE_VERBOSE;
+
+ gdb_argv built_argv (args);
+ for (char *arg : built_argv)
{
- if (strcmp (*argv, "-readnow") == 0)
+ if (strcmp (arg, "-readnow") == 0)
flags |= OBJF_READNOW;
- else if (**argv == '-')
- error (_("unknown option `%s'"), *argv);
+ else if (*arg == '-')
+ error (_("unknown option `%s'"), arg);
else
{
- symbol_file_add_main_1 (*argv, from_tty, flags);
- name = *argv;
+ symbol_file_add_main_1 (arg, add_flags, flags);
+ name = arg;
}
-
- argv++;
}
if (name == NULL)
error (_("no symbol file name was specified"));
-
- do_cleanups (cleanups);
}
}
void
set_initial_language (void)
{
- enum language lang = language_unknown;
+ enum language lang = main_language ();
- if (language_of_main != language_unknown)
- lang = language_of_main;
- else
+ if (lang == language_unknown)
{
- const char *filename;
-
- filename = find_main_filename ();
- if (filename != NULL)
- lang = deduce_language_from_filename (filename);
+ char *name = main_name ();
+ struct symbol *sym = lookup_symbol (name, NULL, VAR_DOMAIN, NULL).symbol;
+
+ if (sym != NULL)
+ lang = SYMBOL_LANGUAGE (sym);
}
if (lang == language_unknown)
expected_language = current_language; /* Don't warn the user. */
}
-/* If NAME is a remote name open the file using remote protocol, otherwise
- open it normally. */
-
-bfd *
-bfd_open_maybe_remote (const char *name)
-{
- if (remote_filename_p (name))
- return remote_bfd_open (name, gnutarget);
- else
- return bfd_openr (name, gnutarget);
-}
-
-
/* Open the file specified by NAME and hand it off to BFD for
preliminary analysis. Return a newly initialized bfd *, which
includes a newly malloc'd` copy of NAME (tilde-expanded and made
absolute). In case of trouble, error() is called. */
-bfd *
-symfile_bfd_open (char *name)
+gdb_bfd_ref_ptr
+symfile_bfd_open (const char *name)
{
- bfd *sym_bfd;
- int desc;
- char *absolute_name;
+ int desc = -1;
+ struct cleanup *back_to = make_cleanup (null_cleanup, 0);
- if (remote_filename_p (name))
+ if (!is_target_filename (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 ()));
- }
+ char *absolute_name;
- 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. */
+ gdb::unique_xmalloc_ptr<char> expanded_name (tilde_expand (name));
- /* Look down path for it, allocate 2nd new malloc'd copy. */
- desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, name,
- O_RDONLY | O_BINARY, &absolute_name);
+ /* Look down path for it, allocate 2nd new malloc'd copy. */
+ desc = openp (getenv ("PATH"),
+ OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH,
+ expanded_name.get (), O_RDONLY | O_BINARY, &absolute_name);
#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
- if (desc < 0)
- {
- char *exename = alloca (strlen (name) + 5);
+ if (desc < 0)
+ {
+ char *exename = (char *) alloca (strlen (expanded_name.get ()) + 5);
- strcat (strcpy (exename, name), ".exe");
- desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, exename,
- O_RDONLY | O_BINARY, &absolute_name);
- }
+ strcat (strcpy (exename, expanded_name.get ()), ".exe");
+ desc = openp (getenv ("PATH"),
+ OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH,
+ exename, O_RDONLY | O_BINARY, &absolute_name);
+ }
#endif
- if (desc < 0)
- {
- make_cleanup (xfree, name);
- perror_with_name (name);
+ if (desc < 0)
+ perror_with_name (expanded_name.get ());
+
+ make_cleanup (xfree, absolute_name);
+ name = absolute_name;
}
- /* Free 1st new malloc'd copy, but keep the 2nd malloc'd copy in
- bfd. It'll be freed in free_objfile(). */
- xfree (name);
- name = absolute_name;
+ gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (name, gnutarget, desc));
+ if (sym_bfd == NULL)
+ error (_("`%s': can't open to read symbols: %s."), name,
+ bfd_errmsg (bfd_get_error ()));
- sym_bfd = bfd_fopen (name, gnutarget, FOPEN_RB, desc);
- if (!sym_bfd)
- {
- close (desc);
- make_cleanup (xfree, name);
- error (_("`%s': can't open to read symbols: %s."), name,
- bfd_errmsg (bfd_get_error ()));
- }
- bfd_set_cacheable (sym_bfd, 1);
+ if (!gdb_bfd_has_target_filename (sym_bfd.get ()))
+ bfd_set_cacheable (sym_bfd.get (), 1);
- if (!bfd_check_format (sym_bfd, bfd_object))
- {
- /* FIXME: should be checking for errors from bfd_close (for one
- thing, on error it does not free all the storage associated
- with the bfd). */
- bfd_close (sym_bfd); /* This also closes desc. */
- make_cleanup (xfree, name);
- error (_("`%s': can't read symbols: %s."), name,
- bfd_errmsg (bfd_get_error ()));
- }
+ if (!bfd_check_format (sym_bfd.get (), bfd_object))
+ error (_("`%s': can't read symbols: %s."), name,
+ bfd_errmsg (bfd_get_error ()));
- /* bfd_usrdata exists for applications and libbfd must not touch it. */
- gdb_assert (bfd_usrdata (sym_bfd) == NULL);
+ do_cleanups (back_to);
return sym_bfd;
}
the section was not found. */
int
-get_section_index (struct objfile *objfile, char *section_name)
+get_section_index (struct objfile *objfile, const char *section_name)
{
asection *sect = bfd_get_section_by_name (objfile->obfd, section_name);
return -1;
}
-/* Link SF into the global symtab_fns list. Called on startup by the
- _initialize routine in each object file format reader, to register
- information about each format the reader is prepared to handle. */
+/* Link SF into the global symtab_fns list.
+ FLAVOUR is the file format that SF handles.
+ Called on startup by the _initialize routine in each object file format
+ reader, to register information about each format the reader is prepared
+ to handle. */
void
-add_symtab_fns (const struct sym_fns *sf)
+add_symtab_fns (enum bfd_flavour flavour, const struct sym_fns *sf)
{
- VEC_safe_push (sym_fns_ptr, symtab_fns, sf);
+ registered_sym_fns fns = { flavour, sf };
+
+ VEC_safe_push (registered_sym_fns, symtab_fns, &fns);
}
/* Initialize OBJFILE to read symbols from its associated BFD. It
static const struct sym_fns *
find_sym_fns (bfd *abfd)
{
- const struct sym_fns *sf;
+ registered_sym_fns *rsf;
enum bfd_flavour our_flavour = bfd_get_flavour (abfd);
int i;
|| our_flavour == bfd_target_tekhex_flavour)
return NULL; /* No symbols. */
- for (i = 0; VEC_iterate (sym_fns_ptr, symtab_fns, i, sf); ++i)
- if (our_flavour == sf->sym_flavour)
- return sf;
+ for (i = 0; VEC_iterate (registered_sym_fns, symtab_fns, i, rsf); ++i)
+ if (our_flavour == rsf->sym_flavour)
+ return rsf->sym_fns;
error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
bfd_get_target (abfd));
static void
load_command (char *arg, int from_tty)
{
+ struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
+
dont_repeat ();
/* The user might be reloading because the binary has changed. Take
if (count)
{
/* We need to quote this string so buildargv can pull it apart. */
- char *temp = xmalloc (strlen (arg) + count + 1 );
+ char *temp = (char *) xmalloc (strlen (arg) + count + 1 );
char *ptemp = temp;
char *prev;
/* After re-loading the executable, we don't really know which
overlays are mapped any more. */
overlay_cache_invalid = 1;
+
+ do_cleanups (cleanup);
}
/* This version of "load" should be usable for any target. Currently
static void
add_section_size_callback (bfd *abfd, asection *asec, void *data)
{
- bfd_size_type *sum = data;
+ bfd_size_type *sum = (bfd_size_type *) data;
*sum += bfd_get_section_size (asec);
}
/* Opaque data for load_section_callback. */
struct load_section_data {
- unsigned long load_offset;
+ CORE_ADDR load_offset;
struct load_progress_data *progress_data;
VEC(memory_write_request_s) *requests;
};
static void
load_progress (ULONGEST bytes, void *untyped_arg)
{
- struct load_progress_section_data *args = untyped_arg;
+ struct load_progress_section_data *args
+ = (struct load_progress_section_data *) untyped_arg;
struct load_progress_data *totals;
if (args == NULL)
{
/* The write is just starting. Let the user know we've started
this section. */
- 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));
+ current_uiout->message ("Loading section %s, size %s lma %s\n",
+ args->section_name,
+ hex_string (args->section_size),
+ paddress (target_gdbarch (), args->lma));
return;
}
might add a verify_memory() method to the target vector and
then use that. remote.c could implement that method using
the ``qCRC'' packet. */
- gdb_byte *check = xmalloc (bytes);
+ gdb_byte *check = (gdb_byte *) xmalloc (bytes);
struct cleanup *verify_cleanups = make_cleanup (xfree, check);
if (target_read_memory (args->lma, check, bytes) != 0)
error (_("Download verify read failed at %s"),
- paddress (target_gdbarch, args->lma));
+ paddress (target_gdbarch (), args->lma));
if (memcmp (args->buffer, check, bytes) != 0)
error (_("Download verify compare failed at %s"),
- paddress (target_gdbarch, args->lma));
+ paddress (target_gdbarch (), args->lma));
do_cleanups (verify_cleanups);
}
totals->data_count += bytes;
args->buffer += bytes;
totals->write_count += 1;
args->section_sent += bytes;
- if (quit_flag
+ if (check_quit_flag ()
|| (deprecated_ui_load_progress_hook != NULL
&& deprecated_ui_load_progress_hook (args->section_name,
args->section_sent)))
load_section_callback (bfd *abfd, asection *asec, void *data)
{
struct memory_write_request *new_request;
- struct load_section_data *args = data;
+ struct load_section_data *args = (struct load_section_data *) data;
struct load_progress_section_data *section_data;
bfd_size_type size = bfd_get_section_size (asec);
gdb_byte *buffer;
new_request = VEC_safe_push (memory_write_request_s,
args->requests, NULL);
memset (new_request, 0, sizeof (struct memory_write_request));
- section_data = xcalloc (1, sizeof (struct load_progress_section_data));
+ section_data = XCNEW (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->data = xmalloc (size);
+ new_request->data = (gdb_byte *) xmalloc (size);
new_request->baton = section_data;
buffer = new_request->data;
static void
clear_memory_write_data (void *arg)
{
- VEC(memory_write_request_s) **vec_p = arg;
+ VEC(memory_write_request_s) **vec_p = (VEC(memory_write_request_s) **) arg;
VEC(memory_write_request_s) *vec = *vec_p;
int i;
struct memory_write_request *mr;
VEC_free (memory_write_request_s, vec);
}
+static void print_transfer_performance (struct ui_file *stream,
+ unsigned long data_count,
+ unsigned long write_count,
+ std::chrono::steady_clock::duration d);
+
void
-generic_load (char *args, int from_tty)
+generic_load (const char *args, int from_tty)
{
- bfd *loadfile_bfd;
- struct timeval start_time, end_time;
- char *filename;
- struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
+ struct cleanup *old_cleanups;
struct load_section_data cbdata;
struct load_progress_data total_progress;
+ struct ui_out *uiout = current_uiout;
CORE_ADDR entry;
- char **argv;
memset (&cbdata, 0, sizeof (cbdata));
memset (&total_progress, 0, sizeof (total_progress));
cbdata.progress_data = &total_progress;
- make_cleanup (clear_memory_write_data, &cbdata.requests);
+ old_cleanups = make_cleanup (clear_memory_write_data, &cbdata.requests);
if (args == NULL)
error_no_arg (_("file to load"));
- argv = gdb_buildargv (args);
- make_cleanup_freeargv (argv);
+ gdb_argv argv (args);
- filename = tilde_expand (argv[0]);
- make_cleanup (xfree, filename);
+ gdb::unique_xmalloc_ptr<char> filename (tilde_expand (argv[0]));
if (argv[1] != NULL)
{
- char *endptr;
+ const char *endptr;
- cbdata.load_offset = strtoul (argv[1], &endptr, 0);
+ cbdata.load_offset = strtoulst (argv[1], &endptr, 0);
/* If the last word was not a valid number then
treat it as a file name with spaces in. */
}
/* Open the file for loading. */
- loadfile_bfd = bfd_openr (filename, gnutarget);
+ gdb_bfd_ref_ptr loadfile_bfd (gdb_bfd_open (filename.get (), gnutarget, -1));
if (loadfile_bfd == NULL)
- {
- perror_with_name (filename);
- return;
- }
+ perror_with_name (filename.get ());
- /* FIXME: should be checking for errors from bfd_close (for one thing,
- on error it does not free all the storage associated with the
- bfd). */
- make_cleanup_bfd_close (loadfile_bfd);
-
- if (!bfd_check_format (loadfile_bfd, bfd_object))
+ if (!bfd_check_format (loadfile_bfd.get (), bfd_object))
{
- error (_("\"%s\" is not an object file: %s"), filename,
+ error (_("\"%s\" is not an object file: %s"), filename.get (),
bfd_errmsg (bfd_get_error ()));
}
- bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
+ bfd_map_over_sections (loadfile_bfd.get (), add_section_size_callback,
(void *) &total_progress.total_size);
- bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
+ bfd_map_over_sections (loadfile_bfd.get (), load_section_callback, &cbdata);
+
+ using namespace std::chrono;
- gettimeofday (&start_time, NULL);
+ steady_clock::time_point start_time = steady_clock::now ();
if (target_write_memory_blocks (cbdata.requests, flash_discard,
load_progress) != 0)
error (_("Load failed"));
- gettimeofday (&end_time, NULL);
+ steady_clock::time_point end_time = steady_clock::now ();
- entry = bfd_get_start_address (loadfile_bfd);
- ui_out_text (uiout, "Start address ");
- 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. */
+ entry = bfd_get_start_address (loadfile_bfd.get ());
+ entry = gdbarch_addr_bits_remove (target_gdbarch (), entry);
+ uiout->text ("Start address ");
+ uiout->field_fmt ("address", "%s", paddress (target_gdbarch (), entry));
+ uiout->text (", load size ");
+ uiout->field_fmt ("load-size", "%lu", total_progress.data_count);
+ uiout->text ("\n");
regcache_write_pc (get_current_regcache (), entry);
/* Reset breakpoints, now that we have changed the load image. For
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
- file is loaded in. Some targets do (e.g., remote-vx.c) but
- others don't (or didn't - perhaps they have all been deleted). */
-
print_transfer_performance (gdb_stdout, total_progress.data_count,
total_progress.write_count,
- &start_time, &end_time);
+ end_time - start_time);
do_cleanups (old_cleanups);
}
-/* Report how fast the transfer went. */
-
-/* DEPRECATED: cagney/1999-10-18: report_transfer_performance is being
- replaced by print_transfer_performance (with a very different
- function signature). */
-
-void
-report_transfer_performance (unsigned long data_count, time_t start_time,
- time_t end_time)
-{
- struct timeval start, end;
-
- start.tv_sec = start_time;
- start.tv_usec = 0;
- end.tv_sec = end_time;
- end.tv_usec = 0;
+/* Report on STREAM the performance of a memory transfer operation,
+ such as 'load'. DATA_COUNT is the number of bytes transferred.
+ WRITE_COUNT is the number of separate write operations, or 0, if
+ that information is not available. TIME is how long the operation
+ lasted. */
- print_transfer_performance (gdb_stdout, data_count, 0, &start, &end);
-}
-
-void
+static void
print_transfer_performance (struct ui_file *stream,
unsigned long data_count,
unsigned long write_count,
- const struct timeval *start_time,
- const struct timeval *end_time)
+ std::chrono::steady_clock::duration time)
{
- ULONGEST time_count;
+ using namespace std::chrono;
+ struct ui_out *uiout = current_uiout;
- /* Compute the elapsed time in milliseconds, as a tradeoff between
- accuracy and overflow. */
- time_count = (end_time->tv_sec - start_time->tv_sec) * 1000;
- time_count += (end_time->tv_usec - start_time->tv_usec) / 1000;
+ milliseconds ms = duration_cast<milliseconds> (time);
- ui_out_text (uiout, "Transfer rate: ");
- if (time_count > 0)
+ uiout->text ("Transfer rate: ");
+ if (ms.count () > 0)
{
- unsigned long rate = ((ULONGEST) data_count * 1000) / time_count;
+ unsigned long rate = ((ULONGEST) data_count * 1000) / ms.count ();
- if (ui_out_is_mi_like_p (uiout))
+ if (uiout->is_mi_like_p ())
{
- ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate * 8);
- ui_out_text (uiout, " bits/sec");
+ uiout->field_fmt ("transfer-rate", "%lu", rate * 8);
+ uiout->text (" bits/sec");
}
else if (rate < 1024)
{
- ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate);
- ui_out_text (uiout, " bytes/sec");
+ uiout->field_fmt ("transfer-rate", "%lu", rate);
+ uiout->text (" bytes/sec");
}
else
{
- ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate / 1024);
- ui_out_text (uiout, " KB/sec");
+ uiout->field_fmt ("transfer-rate", "%lu", rate / 1024);
+ uiout->text (" KB/sec");
}
}
else
{
- ui_out_field_fmt (uiout, "transferred-bits", "%lu", (data_count * 8));
- ui_out_text (uiout, " bits in <1 sec");
+ uiout->field_fmt ("transferred-bits", "%lu", (data_count * 8));
+ uiout->text (" bits in <1 sec");
}
if (write_count > 0)
{
- ui_out_text (uiout, ", ");
- ui_out_field_fmt (uiout, "write-rate", "%lu", data_count / write_count);
- ui_out_text (uiout, " bytes/write");
+ uiout->text (", ");
+ uiout->field_fmt ("write-rate", "%lu", data_count / write_count);
+ uiout->text (" bytes/write");
}
- ui_out_text (uiout, ".\n");
+ uiout->text (".\n");
}
/* This function allows the addition of incrementally linked object files.
value to use. We are now discontinuing this type of ad hoc syntax. */
static void
-add_symbol_file_command (char *args, int from_tty)
+add_symbol_file_command (const char *args, int from_tty)
{
struct gdbarch *gdbarch = get_current_arch ();
- char *filename = NULL;
- int flags = OBJF_USERLOADED;
+ gdb::unique_xmalloc_ptr<char> filename;
char *arg;
- int section_index = 0;
int argcnt = 0;
int sec_num = 0;
- int i;
int expecting_sec_name = 0;
int expecting_sec_addr = 0;
- char **argv;
+ struct objfile *objf;
+ objfile_flags flags = OBJF_USERLOADED | OBJF_SHARED;
+ symfile_add_flags add_flags = 0;
+
+ if (from_tty)
+ add_flags |= SYMFILE_VERBOSE;
struct sect_opt
{
- char *name;
- char *value;
+ const char *name;
+ const char *value;
};
struct section_addr_info *section_addrs;
- struct sect_opt *sect_opts = NULL;
- size_t num_sect_opts = 0;
+ std::vector<sect_opt> sect_opts;
struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL);
- num_sect_opts = 16;
- sect_opts = (struct sect_opt *) xmalloc (num_sect_opts
- * sizeof (struct sect_opt));
-
dont_repeat ();
if (args == NULL)
error (_("add-symbol-file takes a file name and an address"));
- argv = gdb_buildargv (args);
- make_cleanup_freeargv (argv);
+ gdb_argv argv (args);
for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt])
{
if (argcnt == 0)
{
/* The first argument is the file name. */
- filename = tilde_expand (arg);
- make_cleanup (xfree, filename);
+ filename.reset (tilde_expand (arg));
+ }
+ else if (argcnt == 1)
+ {
+ /* The second argument is always the text address at which
+ to load the program. */
+ sect_opt sect = { ".text", arg };
+ sect_opts.push_back (sect);
}
else
- if (argcnt == 1)
- {
- /* The second argument is always the text address at which
- to load the program. */
- sect_opts[section_index].name = ".text";
- sect_opts[section_index].value = arg;
- if (++section_index >= num_sect_opts)
- {
- num_sect_opts *= 2;
- sect_opts = ((struct sect_opt *)
- xrealloc (sect_opts,
- num_sect_opts
- * sizeof (struct sect_opt)));
- }
- }
- else
- {
- /* It's an option (starting with '-') or it's an argument
- to an option. */
-
- if (*arg == '-')
- {
- if (strcmp (arg, "-readnow") == 0)
- flags |= OBJF_READNOW;
- else if (strcmp (arg, "-s") == 0)
- {
- expecting_sec_name = 1;
- expecting_sec_addr = 1;
- }
- }
- else
- {
- if (expecting_sec_name)
- {
- sect_opts[section_index].name = arg;
- expecting_sec_name = 0;
- }
- else
- if (expecting_sec_addr)
- {
- sect_opts[section_index].value = arg;
- expecting_sec_addr = 0;
- if (++section_index >= num_sect_opts)
- {
- num_sect_opts *= 2;
- sect_opts = ((struct sect_opt *)
- xrealloc (sect_opts,
- num_sect_opts
- * sizeof (struct sect_opt)));
- }
- }
- else
- error (_("USAGE: add-symbol-file <filename> <textaddress>"
- " [-mapped] [-readnow] [-s <secname> <addr>]*"));
- }
- }
+ {
+ /* It's an option (starting with '-') or it's an argument
+ to an option. */
+ if (expecting_sec_name)
+ {
+ sect_opt sect = { arg, NULL };
+ sect_opts.push_back (sect);
+ expecting_sec_name = 0;
+ }
+ else if (expecting_sec_addr)
+ {
+ sect_opts.back ().value = arg;
+ expecting_sec_addr = 0;
+ }
+ else if (strcmp (arg, "-readnow") == 0)
+ flags |= OBJF_READNOW;
+ else if (strcmp (arg, "-s") == 0)
+ {
+ expecting_sec_name = 1;
+ expecting_sec_addr = 1;
+ }
+ else
+ error (_("USAGE: add-symbol-file <filename> <textaddress>"
+ " [-readnow] [-s <secname> <addr>]*"));
+ }
}
/* This command takes at least two arguments. The first one is a
filename, and the second is the address where this file has been
loaded. Abort now if this address hasn't been provided by the
user. */
- if (section_index < 1)
- error (_("The address where %s has been loaded is missing"), filename);
+ if (sect_opts.empty ())
+ error (_("The address where %s has been loaded is missing"),
+ filename.get ());
/* Print the prompt for the query below. And save the arguments into
a sect_addr_info structure to be passed around to other
statements because hex_string returns a local static
string. */
- printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename);
- section_addrs = alloc_section_addr_info (section_index);
+ printf_unfiltered (_("add symbol table from file \"%s\" at\n"),
+ filename.get ());
+ section_addrs = alloc_section_addr_info (sect_opts.size ());
make_cleanup (xfree, section_addrs);
- for (i = 0; i < section_index; i++)
+ for (sect_opt § : sect_opts)
{
CORE_ADDR addr;
- char *val = sect_opts[i].value;
- char *sec = sect_opts[i].name;
+ const char *val = sect.value;
+ const char *sec = sect.name;
addr = parse_and_eval_address (val);
/* Here we store the section offsets in the order they were
entered on the command line. */
- section_addrs->other[sec_num].name = sec;
+ section_addrs->other[sec_num].name = (char *) sec;
section_addrs->other[sec_num].addr = addr;
printf_unfiltered ("\t%s_addr = %s\n", sec,
paddress (gdbarch, addr));
At this point, we don't know what file type this is,
so we can't determine what section names are valid. */
}
+ section_addrs->num_sections = sec_num;
if (from_tty && (!query ("%s", "")))
error (_("Not confirmed."));
- symbol_file_add (filename, from_tty ? SYMFILE_VERBOSE : 0,
- section_addrs, flags);
+ objf = symbol_file_add (filename.get (), add_flags, section_addrs, flags);
+
+ add_target_sections_of_objfile (objf);
/* Getting new symbols may change our opinion about what is
frameless. */
}
\f
+/* This function removes a symbol file that was added via add-symbol-file. */
+
+static void
+remove_symbol_file_command (const char *args, int from_tty)
+{
+ struct objfile *objf = NULL;
+ struct program_space *pspace = current_program_space;
+
+ dont_repeat ();
+
+ if (args == NULL)
+ error (_("remove-symbol-file: no symbol file provided"));
+
+ gdb_argv argv (args);
+
+ if (strcmp (argv[0], "-a") == 0)
+ {
+ /* Interpret the next argument as an address. */
+ CORE_ADDR addr;
+
+ if (argv[1] == NULL)
+ error (_("Missing address argument"));
+
+ if (argv[2] != NULL)
+ error (_("Junk after %s"), argv[1]);
+
+ addr = parse_and_eval_address (argv[1]);
+
+ ALL_OBJFILES (objf)
+ {
+ if ((objf->flags & OBJF_USERLOADED) != 0
+ && (objf->flags & OBJF_SHARED) != 0
+ && objf->pspace == pspace && is_addr_in_objfile (addr, objf))
+ break;
+ }
+ }
+ else if (argv[0] != NULL)
+ {
+ /* Interpret the current argument as a file name. */
+
+ if (argv[1] != NULL)
+ error (_("Junk after %s"), argv[0]);
+
+ gdb::unique_xmalloc_ptr<char> filename (tilde_expand (argv[0]));
+
+ ALL_OBJFILES (objf)
+ {
+ if ((objf->flags & OBJF_USERLOADED) != 0
+ && (objf->flags & OBJF_SHARED) != 0
+ && objf->pspace == pspace
+ && filename_cmp (filename.get (), objfile_name (objf)) == 0)
+ break;
+ }
+ }
+
+ if (objf == NULL)
+ error (_("No symbol file found"));
+
+ if (from_tty
+ && !query (_("Remove symbol table from file \"%s\"? "),
+ objfile_name (objf)))
+ error (_("Not confirmed."));
+
+ free_objfile (objf);
+ clear_symtab_users (0);
+}
+
/* Re-read symbols if a symbol-file has changed. */
+
void
reread_symbols (void)
{
struct objfile *objfile;
long new_modtime;
- int reread_one = 0;
struct stat new_statbuf;
int res;
+ std::vector<struct objfile *> new_objfiles;
/* With the addition of shared libraries, this should be modified,
the load time should be saved in the partial symbol tables, since
for (objfile = object_files; objfile; objfile = objfile->next)
{
- /* solib-sunos.c creates one objfile with obfd. */
if (objfile->obfd == NULL)
continue;
if (objfile->obfd->my_archive)
res = stat (objfile->obfd->my_archive->filename, &new_statbuf);
else
- res = stat (objfile->name, &new_statbuf);
+ res = stat (objfile_name (objfile), &new_statbuf);
if (res != 0)
{
/* FIXME, should use print_sys_errmsg but it's not filtered. */
printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
- objfile->name);
+ objfile_name (objfile));
continue;
}
new_modtime = new_statbuf.st_mtime;
struct cleanup *old_cleanups;
struct section_offsets *offsets;
int num_offsets;
- char *obfd_filename;
+ char *original_name;
printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
- objfile->name);
+ objfile_name (objfile));
/* There are various functions like symbol_file_add,
symfile_bfd_open, syms_from_objfile, etc., which might
/* 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)
+ if (exec_bfd != NULL
+ && filename_cmp (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. */
- obfd_filename = bfd_get_filename (objfile->obfd);
- if (!bfd_close (objfile->obfd))
- error (_("Can't close BFD for %s: %s"), objfile->name,
- bfd_errmsg (bfd_get_error ()));
- objfile->obfd = bfd_open_maybe_remote (obfd_filename);
- 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,
- bfd_errmsg (bfd_get_error ()));
+ /* Keep the calls order approx. the same as in free_objfile. */
- /* Save the offsets, we will nuke them with the rest of the
- objfile_obstack. */
- num_offsets = objfile->num_sections;
- offsets = ((struct section_offsets *)
- alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets)));
- memcpy (offsets, objfile->section_offsets,
- SIZEOF_N_SECTION_OFFSETS (num_offsets));
+ /* Free the separate debug objfiles. It will be
+ automatically recreated by sym_read. */
+ free_objfile_separate_debug (objfile);
/* Remove any references to this objfile in the global
value lists. */
clear_objfile_data (objfile);
- /* Free the separate debug objfiles. It will be
- automatically recreated by sym_read. */
- free_objfile_separate_debug (objfile);
+ /* Clean up any state BFD has sitting around. */
+ {
+ gdb_bfd_ref_ptr obfd (objfile->obfd);
+ char *obfd_filename;
+
+ obfd_filename = bfd_get_filename (objfile->obfd);
+ /* Open the new BFD before freeing the old one, so that
+ the filename remains live. */
+ gdb_bfd_ref_ptr temp (gdb_bfd_open (obfd_filename, gnutarget, -1));
+ objfile->obfd = temp.release ();
+ if (objfile->obfd == NULL)
+ error (_("Can't open %s to read symbols."), obfd_filename);
+ }
+
+ original_name = xstrdup (objfile->original_name);
+ make_cleanup (xfree, original_name);
+
+ /* 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 (objfile),
+ bfd_errmsg (bfd_get_error ()));
+
+ /* Save the offsets, we will nuke them with the rest of the
+ objfile_obstack. */
+ num_offsets = objfile->num_sections;
+ offsets = ((struct section_offsets *)
+ alloca (SIZEOF_N_SECTION_OFFSETS (num_offsets)));
+ memcpy (offsets, objfile->section_offsets,
+ SIZEOF_N_SECTION_OFFSETS (num_offsets));
/* FIXME: Do we have to free a whole linked list, or is this
enough? */
/* Free the obstacks for non-reusable objfiles. */
psymbol_bcache_free (objfile->psymbol_cache);
objfile->psymbol_cache = psymbol_bcache_init ();
- bcache_xfree (objfile->macro_cache);
- objfile->macro_cache = bcache_xmalloc (NULL, NULL);
- bcache_xfree (objfile->filename_cache);
- objfile->filename_cache = bcache_xmalloc (NULL,NULL);
- if (objfile->demangled_names_hash != NULL)
- {
- htab_delete (objfile->demangled_names_hash);
- objfile->demangled_names_hash = NULL;
- }
+
+ /* NB: after this call to obstack_free, objfiles_changed
+ will need to be called (see discussion below). */
obstack_free (&objfile->objfile_obstack, 0);
objfile->sections = NULL;
- objfile->symtabs = NULL;
+ objfile->compunit_symtabs = NULL;
objfile->psymtabs = NULL;
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_hash, 0,
- sizeof (objfile->msymbol_hash));
- memset (&objfile->msymbol_demangled_hash, 0,
- sizeof (objfile->msymbol_demangled_hash));
- 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
- functions. */
+ gdb_obstack.h specifies the alloc/dealloc functions. */
obstack_init (&objfile->objfile_obstack);
- if (build_objfile_section_table (objfile))
- {
- error (_("Can't find the file sections in `%s': %s"),
- objfile->name, bfd_errmsg (bfd_get_error ()));
- }
+
+ /* set_objfile_per_bfd potentially allocates the per-bfd
+ data on the objfile's obstack (if sharing data across
+ multiple users is not possible), so it's important to
+ do it *after* the obstack has been initialized. */
+ set_objfile_per_bfd (objfile);
+
+ objfile->original_name
+ = (char *) obstack_copy0 (&objfile->objfile_obstack, original_name,
+ strlen (original_name));
+
+ /* Reset the sym_fns pointer. The ELF reader can change it
+ based on whether .gdb_index is present, and we need it to
+ start over. PR symtab/15885 */
+ objfile_set_sym_fns (objfile, find_sym_fns (objfile->obfd));
+
+ build_objfile_section_table (objfile);
terminate_minimal_symbol_table (objfile);
/* We use the same section offsets as from last time. I'm not
(*objfile->sf->sym_init) (objfile);
clear_complaints (&symfile_complaints, 1, 1);
- /* Do not set flags as this is safe and we don't want to be
- verbose. */
- (*objfile->sf->sym_read) (objfile, 0);
+
+ objfile->flags &= ~OBJF_PSYMTABS_READ;
+
+ /* We are about to read new symbols and potentially also
+ DWARF information. Some targets may want to pass addresses
+ read from DWARF DIE's through an adjustment function before
+ saving them, like MIPS, which may call into
+ "find_pc_section". When called, that function will make
+ use of per-objfile program space data.
+
+ Since we discarded our section information above, we have
+ dangling pointers in the per-objfile program space data
+ structure. Force GDB to update the section mapping
+ information by letting it know the objfile has changed,
+ making the dangling pointers point to correct data
+ again. */
+
+ objfiles_changed ();
+
+ read_symbols (objfile, 0);
+
if (!objfile_has_symbols (objfile))
{
wrap_here ("");
and now, we *want* this to be out of date, so don't call stat
again now. */
objfile->mtime = new_modtime;
- reread_one = 1;
init_entry_point_info (objfile);
+
+ new_objfiles.push_back (objfile);
}
}
- if (reread_one)
+ if (!new_objfiles.empty ())
{
- /* Notify objfiles that we've modified objfile sections. */
- objfiles_changed ();
-
clear_symtab_users (0);
+
+ /* clear_objfile_data for each objfile was called before freeing it and
+ observer_notify_new_objfile (NULL) has been called by
+ clear_symtab_users above. Notify the new files now. */
+ for (auto iter : new_objfiles)
+ observer_notify_new_objfile (iter);
+
/* At least one objfile has changed, so we can consider that
the executable we're debugging has changed too. */
observer_notify_executable_changed ();
}
\f
-
typedef struct
{
char *ext;
enum language lang;
-}
-filename_language;
+} filename_language;
-static filename_language *filename_language_table;
-static int fl_table_size, fl_table_next;
+DEF_VEC_O (filename_language);
-static void
-add_filename_language (char *ext, enum language lang)
+static VEC (filename_language) *filename_language_table;
+
+/* See symfile.h. */
+
+void
+add_filename_language (const char *ext, enum language lang)
{
- if (fl_table_next >= fl_table_size)
- {
- fl_table_size += 10;
- filename_language_table =
- xrealloc (filename_language_table,
- fl_table_size * sizeof (*filename_language_table));
- }
+ filename_language entry;
- filename_language_table[fl_table_next].ext = xstrdup (ext);
- filename_language_table[fl_table_next].lang = lang;
- fl_table_next++;
+ entry.ext = xstrdup (ext);
+ entry.lang = lang;
+
+ VEC_safe_push (filename_language, filename_language_table, &entry);
}
static char *ext_args;
int i;
char *cp = ext_args;
enum language lang;
+ filename_language *entry;
/* First arg is filename extension, starting with '.' */
if (*cp != '.')
*cp++ = '\0';
/* Find beginning of second arg, which should be a source language. */
- while (*cp && isspace (*cp))
- cp++;
+ cp = skip_spaces (cp);
if (*cp == '\0')
error (_("'%s': two arguments required -- "
lang = language_enum (cp);
/* Now lookup the filename extension: do we already know it? */
- for (i = 0; i < fl_table_next; i++)
- if (0 == strcmp (ext_args, filename_language_table[i].ext))
- break;
+ for (i = 0;
+ VEC_iterate (filename_language, filename_language_table, i, entry);
+ ++i)
+ {
+ if (0 == strcmp (ext_args, entry->ext))
+ break;
+ }
- if (i >= fl_table_next)
+ if (entry == NULL)
{
/* New file extension. */
add_filename_language (ext_args, lang);
/* query ("Really make files of type %s '%s'?", */
/* ext_args, language_str (lang)); */
- xfree (filename_language_table[i].ext);
- filename_language_table[i].ext = xstrdup (ext_args);
- filename_language_table[i].lang = lang;
+ xfree (entry->ext);
+ entry->ext = xstrdup (ext_args);
+ entry->lang = lang;
}
}
info_ext_lang_command (char *args, int from_tty)
{
int i;
+ filename_language *entry;
printf_filtered (_("Filename extensions and the languages they represent:"));
printf_filtered ("\n\n");
- for (i = 0; i < fl_table_next; i++)
- printf_filtered ("\t%s\t- %s\n",
- filename_language_table[i].ext,
- language_str (filename_language_table[i].lang));
-}
-
-static void
-init_filename_language_table (void)
-{
- if (fl_table_size == 0) /* Protect against repetition. */
- {
- fl_table_size = 20;
- fl_table_next = 0;
- 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 (".cpp", language_cplus);
- add_filename_language (".cxx", language_cplus);
- add_filename_language (".c++", language_cplus);
- add_filename_language (".java", language_java);
- add_filename_language (".class", language_java);
- 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 (".pas", language_pascal);
- add_filename_language (".p", language_pascal);
- add_filename_language (".pp", language_pascal);
- add_filename_language (".adb", language_ada);
- add_filename_language (".ads", language_ada);
- add_filename_language (".a", language_ada);
- add_filename_language (".ada", language_ada);
- add_filename_language (".dg", language_ada);
- }
+ for (i = 0;
+ VEC_iterate (filename_language, filename_language_table, i, entry);
+ ++i)
+ printf_filtered ("\t%s\t- %s\n", entry->ext, language_str (entry->lang));
}
enum language
deduce_language_from_filename (const char *filename)
{
int i;
- char *cp;
+ const char *cp;
if (filename != NULL)
if ((cp = strrchr (filename, '.')) != NULL)
- for (i = 0; i < fl_table_next; i++)
- if (strcmp (cp, filename_language_table[i].ext) == 0)
- return filename_language_table[i].lang;
+ {
+ filename_language *entry;
+
+ for (i = 0;
+ VEC_iterate (filename_language, filename_language_table, i, entry);
+ ++i)
+ if (strcmp (cp, entry->ext) == 0)
+ return entry->lang;
+ }
return language_unknown;
}
\f
-/* allocate_symtab:
-
- Allocate and partly initialize a new symbol table. Return a pointer
- to it. error() if no space.
-
- Caller must set these fields:
- LINETABLE(symtab)
- symtab->blockvector
- symtab->dirname
- symtab->free_code
- symtab->free_ptr
- */
+/* Allocate and initialize a new symbol table.
+ CUST is from the result of allocate_compunit_symtab. */
struct symtab *
-allocate_symtab (const char *filename, struct objfile *objfile)
+allocate_symtab (struct compunit_symtab *cust, const char *filename)
{
- struct symtab *symtab;
+ struct objfile *objfile = cust->objfile;
+ struct symtab *symtab
+ = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symtab);
- symtab = (struct symtab *)
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symtab));
- memset (symtab, 0, sizeof (*symtab));
- symtab->filename = (char *) bcache (filename, strlen (filename) + 1,
- objfile->filename_cache);
+ symtab->filename
+ = (const char *) bcache (filename, strlen (filename) + 1,
+ objfile->per_bfd->filename_cache);
symtab->fullname = NULL;
symtab->language = deduce_language_from_filename (filename);
- symtab->debugformat = "unknown";
- /* Hook it to the objfile it comes from. */
+ /* This can be very verbose with lots of headers.
+ Only print at higher debug levels. */
+ if (symtab_create_debug >= 2)
+ {
+ /* Be a bit clever with debugging messages, and don't print objfile
+ every time, only when it changes. */
+ static char *last_objfile_name = NULL;
+
+ if (last_objfile_name == NULL
+ || strcmp (last_objfile_name, objfile_name (objfile)) != 0)
+ {
+ xfree (last_objfile_name);
+ last_objfile_name = xstrdup (objfile_name (objfile));
+ fprintf_unfiltered (gdb_stdlog,
+ "Creating one or more symtabs for objfile %s ...\n",
+ last_objfile_name);
+ }
+ fprintf_unfiltered (gdb_stdlog,
+ "Created symtab %s for module %s.\n",
+ host_address_to_string (symtab), filename);
+ }
+
+ /* Add it to CUST's list of symtabs. */
+ if (cust->filetabs == NULL)
+ {
+ cust->filetabs = symtab;
+ cust->last_filetab = symtab;
+ }
+ else
+ {
+ cust->last_filetab->next = symtab;
+ cust->last_filetab = symtab;
+ }
- symtab->objfile = objfile;
- symtab->next = objfile->symtabs;
- objfile->symtabs = symtab;
+ /* Backlink to the containing compunit symtab. */
+ symtab->compunit_symtab = cust;
- return (symtab);
+ return symtab;
+}
+
+/* Allocate and initialize a new compunit.
+ NAME is the name of the main source file, if there is one, or some
+ descriptive text if there are no source files. */
+
+struct compunit_symtab *
+allocate_compunit_symtab (struct objfile *objfile, const char *name)
+{
+ struct compunit_symtab *cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+ struct compunit_symtab);
+ const char *saved_name;
+
+ cu->objfile = objfile;
+
+ /* The name we record here is only for display/debugging purposes.
+ Just save the basename to avoid path issues (too long for display,
+ relative vs absolute, etc.). */
+ saved_name = lbasename (name);
+ cu->name
+ = (const char *) obstack_copy0 (&objfile->objfile_obstack, saved_name,
+ strlen (saved_name));
+
+ COMPUNIT_DEBUGFORMAT (cu) = "unknown";
+
+ if (symtab_create_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "Created compunit symtab %s for %s.\n",
+ host_address_to_string (cu),
+ cu->name);
+ }
+
+ return cu;
+}
+
+/* Hook CU to the objfile it comes from. */
+
+void
+add_compunit_symtab_to_objfile (struct compunit_symtab *cu)
+{
+ cu->next = cu->objfile->compunit_symtabs;
+ cu->objfile->compunit_symtabs = cu;
}
\f
-/* Reset all data structures in gdb which may contain references to symbol
- table data. ADD_FLAGS is a bitmask of enum symfile_add_flags. */
+/* Reset all data structures in gdb which may contain references to
+ symbol table data. */
void
-clear_symtab_users (int add_flags)
+clear_symtab_users (symfile_add_flags 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 ();
- if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
- breakpoint_re_set ();
- set_default_breakpoint (0, NULL, 0, 0, 0);
+ clear_last_displayed_sal ();
clear_pc_function_cache ();
observer_notify_new_objfile (NULL);
/* Varobj may refer to old symbols, perform a cleanup. */
varobj_invalidate ();
+ /* Now that the various caches have been cleared, we can re_set
+ our breakpoints without risking it using stale data. */
+ if ((add_flags & SYMFILE_DEFER_BP_RESET) == 0)
+ breakpoint_re_set ();
}
static void
{
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 0;
}
-
/* Return true if the mapped ranges of sections A and B overlap, false
otherwise. */
+
static int
sections_overlap (struct obj_section *a, struct obj_section *b)
{
return pc;
}
-
/* Function: symbol_overlayed_address
Return one of two addresses (relative to the VMA or to the LMA),
depending on whether the section is mapped or not. */
struct obj_section *osect, *best_match = NULL;
if (overlay_debugging)
- ALL_OBJSECTIONS (objfile, osect)
- if (section_is_overlay (osect))
- {
- if (pc_in_mapped_range (pc, osect))
+ {
+ ALL_OBJSECTIONS (objfile, osect)
+ if (section_is_overlay (osect))
{
- if (section_is_mapped (osect))
- return osect;
- else
+ if (pc_in_mapped_range (pc, osect))
+ {
+ if (section_is_mapped (osect))
+ return osect;
+ else
+ best_match = osect;
+ }
+ else if (pc_in_unmapped_range (pc, osect))
best_match = osect;
}
- else if (pc_in_unmapped_range (pc, osect))
- best_match = osect;
- }
+ }
return best_match;
}
struct obj_section *osect;
if (overlay_debugging)
- ALL_OBJSECTIONS (objfile, osect)
- if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
- return osect;
+ {
+ ALL_OBJSECTIONS (objfile, osect)
+ if (pc_in_mapped_range (pc, osect) && section_is_mapped (osect))
+ return osect;
+ }
return NULL;
}
/* Function: list_overlays_command
Print a list of mapped sections and their PC ranges. */
-void
-list_overlays_command (char *args, int from_tty)
+static void
+list_overlays_command (const char *args, int from_tty)
{
int nmapped = 0;
struct objfile *objfile;
struct obj_section *osect;
if (overlay_debugging)
- ALL_OBJSECTIONS (objfile, osect)
+ {
+ 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;
-
- vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
- lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
- size = bfd_get_section_size (osect->the_bfd_section);
- name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
-
- printf_filtered ("Section %s, loaded at ", name);
- fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
- puts_filtered (" - ");
- fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
- printf_filtered (", mapped at ");
- fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
- puts_filtered (" - ");
- fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
- puts_filtered ("\n");
-
- nmapped++;
- }
+ {
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ const char *name;
+ bfd_vma lma, vma;
+ int size;
+
+ vma = bfd_section_vma (objfile->obfd, osect->the_bfd_section);
+ lma = bfd_section_lma (objfile->obfd, osect->the_bfd_section);
+ size = bfd_get_section_size (osect->the_bfd_section);
+ name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
+
+ printf_filtered ("Section %s, loaded at ", name);
+ fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
+ puts_filtered (" - ");
+ fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
+ printf_filtered (", mapped at ");
+ fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
+ puts_filtered (" - ");
+ fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
+ puts_filtered ("\n");
+
+ nmapped++;
+ }
+ }
if (nmapped == 0)
printf_filtered (_("No sections are mapped.\n"));
}
/* Function: map_overlay_command
Mark the named section as mapped (ie. residing at its VMA address). */
-void
-map_overlay_command (char *args, int from_tty)
+static void
+map_overlay_command (const char *args, int from_tty)
{
struct objfile *objfile, *objfile2;
struct obj_section *sec, *sec2;
Mark the overlay section as unmapped
(ie. resident in its LMA address range, rather than the VMA range). */
-void
-unmap_overlay_command (char *args, int from_tty)
+static void
+unmap_overlay_command (const char *args, int from_tty)
{
struct objfile *objfile;
- struct obj_section *sec;
+ struct obj_section *sec = NULL;
if (!overlay_debugging)
error (_("Overlay debugging not enabled. "
Possibly this should be done via a set/show command. */
static void
-overlay_auto_command (char *args, int from_tty)
+overlay_auto_command (const char *args, int from_tty)
{
overlay_debugging = ovly_auto;
enable_overlay_breakpoints ();
Possibly this should be done via a set/show command. */
static void
-overlay_manual_command (char *args, int from_tty)
+overlay_manual_command (const char *args, int from_tty)
{
overlay_debugging = ovly_on;
disable_overlay_breakpoints ();
Possibly this should be done via a set/show command. */
static void
-overlay_off_command (char *args, int from_tty)
+overlay_off_command (const char *args, int from_tty)
{
overlay_debugging = ovly_off;
disable_overlay_breakpoints ();
}
static void
-overlay_load_command (char *args, int from_tty)
+overlay_load_command (const char *args, int from_tty)
{
struct gdbarch *gdbarch = get_current_arch ();
A place-holder for a mis-typed command. */
/* Command list chain containing all defined "overlay" subcommands. */
-struct cmd_list_element *overlaylist;
+static struct cmd_list_element *overlaylist;
static void
overlay_command (char *args, int from_tty)
{
printf_unfiltered
("\"overlay\" must be followed by the name of an overlay command.\n");
- help_list (overlaylist, "overlay ", -1, gdb_stdout);
+ help_list (overlaylist, "overlay ", all_commands, gdb_stdout);
}
-
/* Target Overlays for the "Simplest" overlay manager:
This is GDB's default target overlay layer. It works with the
In this simple implementation, the target data structures are as follows:
unsigned _novlys; /# number of overlay sections #/
unsigned _ovly_table[_novlys][4] = {
- {VMA, SIZE, LMA, MAPPED}, /# one entry per overlay section #/
+ {VMA, OSIZE, LMA, MAPPED}, /# one entry per overlay section #/
{..., ..., ..., ...},
}
unsigned _novly_regions; /# number of overlay regions #/
unsigned _ovly_region_table[_novly_regions][3] = {
- {VMA, SIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
+ {VMA, OSIZE, MAPPED_TO_LMA}, /# one entry per overlay region #/
{..., ..., ...},
}
These functions will attempt to update GDB's mappedness state in the
static CORE_ADDR cache_ovly_table_base = 0;
enum ovly_index
{
- VMA, SIZE, LMA, MAPPED
+ VMA, OSIZE, LMA, MAPPED
};
/* Throw away the cached copy of _ovly_table. */
+
static void
simple_free_overlay_table (void)
{
/* 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, int size, enum bfd_endian byte_order)
{
/* FIXME (alloca): Not safe if array is very large. */
- gdb_byte *buf = alloca (len * size);
+ gdb_byte *buf = (gdb_byte *) alloca (len * size);
int i;
read_memory (memaddr, buf, len * size);
/* Find and grab a copy of the target _ovly_table
(and _novlys, which is needed for the table's size). */
+
static int
simple_read_overlay_table (void)
{
- struct minimal_symbol *novlys_msym, *ovly_table_msym;
+ struct bound_minimal_symbol novlys_msym;
+ struct bound_minimal_symbol 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);
- if (! novlys_msym)
+ if (! novlys_msym.minsym)
{
error (_("Error reading inferior's overlay table: "
"couldn't find `_novlys' variable\n"
return 0;
}
- ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
- if (! ovly_table_msym)
+ ovly_table_msym = lookup_bound_minimal_symbol ("_ovly_table");
+ if (! ovly_table_msym.minsym)
{
error (_("Error reading inferior's overlay table: couldn't find "
"`_ovly_table' array\n"
return 0;
}
- gdbarch = get_objfile_arch (msymbol_objfile (ovly_table_msym));
+ gdbarch = get_objfile_arch (ovly_table_msym.objfile);
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),
+ cache_novlys = read_memory_integer (BMSYMBOL_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);
+ = (unsigned int (*)[4]) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
+ cache_ovly_table_base = BMSYMBOL_VALUE_ADDRESS (ovly_table_msym);
read_target_long_array (cache_ovly_table_base,
(unsigned int *) cache_ovly_table,
cache_novlys * 4, word_size, byte_order);
static int
simple_overlay_update_1 (struct obj_section *osect)
{
- int i, size;
+ int i;
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++)
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 */ )
+ && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect))
{
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 */ )
+ && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect))
{
osect->ovly_mapped = cache_ovly_table[i][MAPPED];
return 1;
{
/* Does its cached location match what's currently in the
symtab? */
- struct minimal_symbol *minsym
+ struct bound_minimal_symbol minsym
= lookup_minimal_symbol ("_ovly_table", NULL, NULL);
- if (minsym == NULL)
+ if (minsym.minsym == NULL)
error (_("Error reading inferior's overlay table: couldn't "
"find `_ovly_table' array\n"
"in inferior. Use `overlay manual' mode."));
- if (cache_ovly_table_base == SYMBOL_VALUE_ADDRESS (minsym))
+ if (cache_ovly_table_base == BMSYMBOL_VALUE_ADDRESS (minsym))
/* Then go ahead and try to look up this single section in
the cache. */
if (simple_overlay_update_1 (osect))
ALL_OBJSECTIONS (objfile, osect)
if (section_is_overlay (osect))
{
- int i, size;
+ int i;
bfd *obfd = osect->objfile->obfd;
asection *bsect = osect->the_bfd_section;
- size = bfd_get_section_size (bsect);
for (i = 0; i < cache_novlys; i++)
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 */ )
+ && cache_ovly_table[i][LMA] == bfd_section_lma (obfd, bsect))
{ /* obj_section matches i'th entry in ovly_table. */
osect->ovly_mapped = cache_ovly_table[i][MAPPED];
break; /* finished with inner for loop: break out. */
/* Default implementation for sym_relocate. */
-
bfd_byte *
default_symfile_relocate (struct objfile *objfile, asection *sectp,
bfd_byte *buf)
{
- bfd *abfd = objfile->obfd;
+ /* Use sectp->owner instead of objfile->obfd. sectp may point to a
+ DWO file. */
+ bfd *abfd = sectp->owner;
/* We're only interested in sections with relocation
information. */
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,
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,
+symfile_map_offsets_to_segments (bfd *abfd,
+ const struct symfile_segment_data *data,
struct section_offsets *offsets,
int num_segment_bases,
const CORE_ADDR *segment_bases)
free_symfile_segment_data (data);
}
+/* Listen for free_objfile events. */
+
+static void
+symfile_free_objfile (struct objfile *objfile)
+{
+ /* Remove the target sections owned by this objfile. */
+ if (objfile != NULL)
+ remove_target_sections ((void *) objfile);
+}
+
+/* Wrapper around the quick_symbol_functions expand_symtabs_matching "method".
+ Expand all symtabs that match the specified criteria.
+ See quick_symbol_functions.expand_symtabs_matching for details. */
+
+void
+expand_symtabs_matching
+ (gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
+ gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
+ gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
+ enum search_domain kind)
+{
+ struct objfile *objfile;
+
+ ALL_OBJFILES (objfile)
+ {
+ if (objfile->sf)
+ objfile->sf->qf->expand_symtabs_matching (objfile, file_matcher,
+ symbol_matcher,
+ expansion_notify, kind);
+ }
+}
+
+/* Wrapper around the quick_symbol_functions map_symbol_filenames "method".
+ Map function FUN over every file.
+ See quick_symbol_functions.map_symbol_filenames for details. */
+
+void
+map_symbol_filenames (symbol_filename_ftype *fun, void *data,
+ int need_fullname)
+{
+ struct objfile *objfile;
+
+ ALL_OBJFILES (objfile)
+ {
+ if (objfile->sf)
+ objfile->sf->qf->map_symbol_filenames (objfile, fun, data,
+ need_fullname);
+ }
+}
+
void
_initialize_symfile (void)
{
struct cmd_list_element *c;
+ observer_attach_free_objfile (symfile_free_objfile);
+
c = add_cmd ("symbol-file", class_files, symbol_file_command, _("\
Load symbol table from executable file FILE.\n\
The `file' command can also load symbol tables, as well as setting the file\n\
&cmdlist);
set_cmd_completer (c, filename_completer);
+ c = add_cmd ("remove-symbol-file", class_files,
+ remove_symbol_file_command, _("\
+Remove a symbol file added via the add-symbol-file command.\n\
+Usage: remove-symbol-file FILENAME\n\
+ remove-symbol-file -a ADDRESS\n\
+The file to remove can be identified by its filename or by an address\n\
+that lies within the boundaries of this symbol file in memory."),
+ &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\
-A load OFFSET may also be given."), &cmdlist);
+An optional load OFFSET may also be given as a literal address.\n\
+When OFFSET is provided, FILE must also be provided. FILE can be provided\n\
+on its own.\n\
+Usage: load [FILE] [OFFSET]"), &cmdlist);
set_cmd_completer (c, filename_completer);
- add_setshow_boolean_cmd ("symbol-reloading", class_support,
- &symbol_reloading, _("\
-Set dynamic symbol table reloading multiple times in one run."), _("\
-Show dynamic symbol table reloading multiple times in one run."), NULL,
- NULL,
- show_symbol_reloading,
- &setlist, &showlist);
-
add_prefix_cmd ("overlay", class_support, overlay_command,
_("Commands for debugging overlays."), &overlaylist,
"overlay ", 0, &cmdlist);
_("Read the overlay mapping state from the target."), &overlaylist);
/* Filename extension to source language lookup table: */
- init_filename_language_table ();
add_setshow_string_noescape_cmd ("extension-language", class_files,
&ext_args, _("\
Set mapping between filename extension and source language."), _("\
NULL,
show_debug_file_directory,
&setlist, &showlist);
+
+ add_setshow_enum_cmd ("symbol-loading", no_class,
+ print_symbol_loading_enums, &print_symbol_loading,
+ _("\
+Set printing of symbol loading messages."), _("\
+Show printing of symbol loading messages."), _("\
+off == turn all messages off\n\
+brief == print messages for the executable,\n\
+ and brief messages for shared libraries\n\
+full == print messages for the executable,\n\
+ and messages for each shared library."),
+ NULL,
+ NULL,
+ &setprintlist, &showprintlist);
+
+ add_setshow_boolean_cmd ("separate-debug-file", no_class,
+ &separate_debug_file_debug, _("\
+Set printing of separate debug info file search debug."), _("\
+Show printing of separate debug info file search debug."), _("\
+When on, GDB prints the searched locations while looking for separate debug \
+info files."), NULL, NULL, &setdebuglist, &showdebuglist);
}