/* Generic symbol file reading for the GNU debugger, GDB.
- Copyright (C) 1990-2012 Free Software Foundation, Inc.
+ Copyright (C) 1990-2013 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
#include "remote.h"
#include "stack.h"
#include "gdb_bfd.h"
+#include "cli/cli-utils.h"
#include <sys/types.h>
#include <fcntl.h>
static void add_symbol_file_command (char *, int);
-bfd *symfile_bfd_open (char *);
-
-int get_section_index (struct objfile *, char *);
-
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);
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;
-}
-
-/* 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, ...)
-{
- va_list ap;
-
- va_start (ap, obstackp);
- for (;;)
- {
- const char *s = va_arg (ap, const char *);
-
- if (s == NULL)
- break;
-
- obstack_grow_str (obstackp, s);
- }
- va_end (ap);
- obstack_1grow (obstackp, 0);
-
- return obstack_finish (obstackp);
-}
-
/* True if we are reading a symbol table. */
int currently_reading_symtab = 0;
decrement_reading_symtab (void *dummy)
{
currently_reading_symtab--;
+ gdb_assert (currently_reading_symtab >= 0);
}
/* Increment currently_reading_symtab and return a cleanup that can be
used to decrement it. */
+
struct cleanup *
increment_reading_symtab (void)
{
++currently_reading_symtab;
+ gdb_assert (currently_reading_symtab > 0);
return make_cleanup (decrement_reading_symtab, NULL);
}
*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;
}
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].sectindex
+ = gdb_bfd_section_index (stp->bfd, stp->the_bfd_section);
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)
{
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->sectindex == -1)
/* `+ 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++)
+ for (i = 0; i < addrs->num_sections; i++)
array[i] = &addrs->other[i];
array[i] = NULL;
(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];
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.
read_symbols (struct objfile *objfile, int add_flags)
{
(*objfile->sf->sym_read) (objfile, add_flags);
- if (!objfile_has_partial_symbols (objfile))
+
+ /* 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)
{
bfd *abfd = find_separate_debug_file_in_section (objfile);
struct cleanup *cleanup = make_cleanup_bfd_unref (abfd);
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
static void
syms_from_objfile_1 (struct objfile *objfile,
struct section_addr_info *addrs,
- struct section_offsets *offsets,
- int num_offsets,
int add_flags)
{
struct section_addr_info *local_addr = NULL;
struct cleanup *old_chain;
const int mainline = add_flags & SYMFILE_MAINLINE;
- gdb_assert (! (addrs && offsets));
-
objfile->sf = find_sym_fns (objfile->obfd);
if (objfile->sf == NULL)
{
/* No symbols to load, but we still need to make sure
that the section_offsets table is allocated. */
- int num_sections = bfd_count_sections (objfile->obfd);
- size_t size = SIZEOF_N_SECTION_OFFSETS (num_offsets);
+ 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
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);
-
- init_objfile_sect_indices (objfile);
- }
+ (*objfile->sf->sym_offsets) (objfile, addrs);
read_symbols (objfile, add_flags);
/* Same as syms_from_objfile_1, but also initializes the objfile
entry-point info. */
-void
+static void
syms_from_objfile (struct objfile *objfile,
struct section_addr_info *addrs,
- struct section_offsets *offsets,
- int num_offsets,
int add_flags)
{
- syms_from_objfile_1 (objfile, addrs, offsets, num_offsets, add_flags);
+ syms_from_objfile_1 (objfile, addrs, add_flags);
init_entry_point_info (objfile);
}
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.
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, struct objfile *parent)
+symbol_file_add_with_addrs (bfd *abfd, int add_flags,
+ struct section_addr_info *addrs,
+ int flags, struct objfile *parent)
{
struct objfile *objfile;
const char *name = bfd_get_filename (abfd);
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
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,
+ new_objfile = symbol_file_add_with_addrs
+ (bfd, symfile_flags, sap,
objfile->flags & (OBJF_REORDERED | OBJF_SHARED | OBJF_READNOW
| OBJF_USERLOADED),
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,
struct section_addr_info *addrs,
int flags, struct objfile *parent)
{
- return symbol_file_add_with_addrs_or_offsets (abfd, add_flags, addrs, 0, 0,
- flags, parent);
+ return symbol_file_add_with_addrs (abfd, 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)
return objf;
}
-
/* Call symbol_file_add() with default values and update whatever is
affected by the loading of a new main().
Used when the file is supplied in the gdb command line
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");
-
- 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;
-}
-
-/* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
- return 1. Otherwise print a warning and return 0. ABFD seek position is
- not preserved. */
-
-static int
-get_file_crc (bfd *abfd, unsigned long *file_crc_return)
-{
- unsigned long file_crc = 0;
-
- if (bfd_seek (abfd, 0, SEEK_SET) != 0)
- {
- warning (_("Problem reading \"%s\" for CRC: %s"),
- bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
- return 0;
- }
-
- for (;;)
- {
- gdb_byte buffer[8 * 1024];
- bfd_size_type count;
-
- count = bfd_bread (buffer, sizeof (buffer), abfd);
- if (count == (bfd_size_type) -1)
- {
- warning (_("Problem reading \"%s\" for CRC: %s"),
- bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
- return 0;
- }
- if (count == 0)
- break;
- file_crc = gnu_debuglink_crc32 (file_crc, buffer, count);
- }
-
- *file_crc_return = file_crc;
- return 1;
-}
-
static int
separate_debug_file_exists (const char *name, unsigned long crc,
struct objfile *parent_objfile)
else
verified_as_different = 0;
- file_crc_p = get_file_crc (abfd, &file_crc);
+ file_crc_p = gdb_bfd_crc (abfd, &file_crc);
gdb_bfd_unref (abfd);
if (crc != file_crc)
{
+ unsigned long parent_crc;
+
/* If one (or both) the files are accessed for example the via "remote:"
gdbserver way it does not support the bfd_stat operation. Verify
whether those two files are not the same manually. */
- if (!verified_as_different && !parent_objfile->crc32_p)
+ if (!verified_as_different)
{
- parent_objfile->crc32_p = get_file_crc (parent_objfile->obfd,
- &parent_objfile->crc32);
- if (!parent_objfile->crc32_p)
+ if (!gdb_bfd_crc (parent_objfile->obfd, &parent_crc))
return 0;
}
- if (verified_as_different || parent_objfile->crc32 != file_crc)
+ if (verified_as_different || parent_crc != file_crc)
warning (_("the debug information found in \"%s\""
" does not match \"%s\" (CRC mismatch).\n"),
name, parent_objfile->name);
/* 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. Returns the name of the debuginfo, of NULL. */
+ 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,
strcat (debugfile, debuglink);
if (separate_debug_file_exists (debugfile, crc32, objfile))
- 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. */
strcat (debugfile, debuglink);
if (separate_debug_file_exists (debugfile, crc32, objfile))
- return debugfile;
+ {
+ do_cleanups (back_to);
+ return debugfile;
+ }
}
}
return NULL;
}
-/* Modify PATH to contain only "directory/" part of PATH.
+/* Modify PATH to contain only "[/]directory/" part of PATH.
If there were no directory separators in PATH, PATH will be empty
string on return. */
unsigned long crc32;
struct cleanup *cleanups;
- debuglink = get_debug_link_info (objfile, &crc32);
+ debuglink = bfd_get_debug_link_info (objfile->obfd, &crc32);
if (debuglink == NULL)
{
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
the command is rather bizarre:
return result;
}
-
/* 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
bfd *sym_bfd;
int desc;
char *absolute_name;
+ struct cleanup *back_to;
if (remote_filename_p (name))
{
xfree (name);
name = absolute_name;
- make_cleanup (xfree, name);
+ back_to = make_cleanup (xfree, name);
sym_bfd = gdb_bfd_open (name, gnutarget, desc);
if (!sym_bfd)
- {
- make_cleanup (xfree, name);
- error (_("`%s': can't open to read symbols: %s."), name,
- bfd_errmsg (bfd_get_error ()));
- }
+ error (_("`%s': can't open to read symbols: %s."), name,
+ bfd_errmsg (bfd_get_error ()));
bfd_set_cacheable (sym_bfd, 1);
if (!bfd_check_format (sym_bfd, bfd_object))
bfd_errmsg (bfd_get_error ()));
}
+ do_cleanups (back_to);
+
return sym_bfd;
}
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
/* 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
/* 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;
};
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. */
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."));
DEF_VEC_P (objfilep);
/* Re-read symbols if a symbol-file has changed. */
+
void
reread_symbols (void)
{
}
\f
-
typedef struct
{
char *ext;
*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 -- "
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. */
/* Function: list_overlays_command
Print a list of mapped sections and their PC ranges. */
-void
+static void
list_overlays_command (char *args, int from_tty)
{
int nmapped = 0;
/* Function: map_overlay_command
Mark the named section as mapped (ie. residing at its VMA address). */
-void
+static void
map_overlay_command (char *args, int from_tty)
{
struct objfile *objfile, *objfile2;
Mark the overlay section as unmapped
(ie. resident in its LMA address range, rather than the VMA range). */
-void
+static void
unmap_overlay_command (char *args, int from_tty)
{
struct objfile *objfile;
help_list (overlaylist, "overlay ", -1, gdb_stdout);
}
-
/* Target Overlays for the "Simplest" overlay manager:
This is GDB's default target overlay layer. It works with the
};
/* 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)
/* 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)
{
/* Default implementation for sym_relocate. */
-
bfd_byte *
default_symfile_relocate (struct objfile *objfile, asection *sectp,
bfd_byte *buf)
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)