/* Generic symbol file reading for the GNU debugger, GDB.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "bfdlink.h"
#include "readline/readline.h"
#include "gdb_assert.h"
#include "block.h"
+#include "observer.h"
+#include "exec.h"
#include <sys/types.h>
#include <fcntl.h>
#include "gdb_stat.h"
#include <ctype.h>
#include <time.h>
+#include <sys/time.h>
#ifndef O_BINARY
#define O_BINARY 0
#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)
+{
+ fprintf_filtered (file, _("\
+Dynamic symbol table reloading multiple times in one run is %s.\n"),
+ value);
+}
+
/* If non-zero, shared library symbols will be added automatically
when the inferior is created, new libraries are loaded, or when
}
}
+/* The arguments to place_section. */
+
+struct place_section_arg
+{
+ struct section_offsets *offsets;
+ CORE_ADDR lowest;
+};
+
+/* Find a unique offset to use for loadable section SECT if
+ the user did not provide an offset. */
+
+void
+place_section (bfd *abfd, asection *sect, void *obj)
+{
+ struct place_section_arg *arg = obj;
+ CORE_ADDR *offsets = arg->offsets->offsets, start_addr;
+ int done;
+
+ /* We are only interested in loadable sections. */
+ if ((bfd_get_section_flags (abfd, sect) & SEC_LOAD) == 0)
+ return;
+
+ /* If the user specified an offset, honor it. */
+ if (offsets[sect->index] != 0)
+ return;
+
+ /* Otherwise, let's try to find a place for the section. */
+ do {
+ asection *cur_sec;
+ ULONGEST align = 1 << bfd_get_section_alignment (abfd, sect);
+
+ start_addr = (arg->lowest + align - 1) & -align;
+ done = 1;
+
+ for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
+ {
+ int indx = cur_sec->index;
+ CORE_ADDR cur_offset;
+
+ /* We don't need to compare against ourself. */
+ if (cur_sec == sect)
+ continue;
+
+ /* We can only conflict with loadable sections. */
+ if ((bfd_get_section_flags (abfd, cur_sec) & SEC_LOAD) == 0)
+ continue;
+
+ /* We do not expect this to happen; just ignore sections in a
+ relocatable file with an assigned VMA. */
+ if (bfd_section_vma (abfd, cur_sec) != 0)
+ continue;
+
+ /* If the section offset is 0, either the section has not been placed
+ yet, or it was the lowest section placed (in which case LOWEST
+ will be past its end). */
+ if (offsets[indx] == 0)
+ continue;
+
+ /* If this section would overlap us, then we must move up. */
+ if (start_addr + bfd_get_section_size (sect) > offsets[indx]
+ && start_addr < offsets[indx] + bfd_get_section_size (cur_sec))
+ {
+ start_addr = offsets[indx] + bfd_get_section_size (cur_sec);
+ start_addr = (start_addr + align - 1) & -align;
+ done = 0;
+ continue;
+ }
+
+ /* Otherwise, we appear to be OK. So far. */
+ }
+ }
+ while (!done);
+
+ offsets[sect->index] = start_addr;
+ arg->lowest = start_addr + bfd_get_section_size (sect);
+
+ exec_set_section_address (bfd_get_filename (abfd), sect->index, start_addr);
+}
/* Parse the user's idea of an offset for dynamic linking, into our idea
of how to represent it for fast symbol reading. This is the default
(objfile->section_offsets)->offsets[osp->sectindex] = osp->addr;
}
+ /* For relocatable files, all loadable sections will start at zero.
+ The zero is meaningless, so try to pick arbitrary addresses such
+ that no loadable sections overlap. This algorithm is quadratic,
+ but the number of sections in a single object file is generally
+ small. */
+ if ((bfd_get_file_flags (objfile->obfd) & (EXEC_P | DYNAMIC)) == 0)
+ {
+ struct place_section_arg arg;
+ arg.offsets = objfile->section_offsets;
+ arg.lowest = 0;
+ bfd_map_over_sections (objfile->obfd, place_section, &arg);
+ }
+
/* Remember the bfd indexes for the .text, .data, .bss and
.rodata sections. */
init_objfile_sect_indices (objfile);
{
if ((have_full_symbols () || have_partial_symbols ())
&& from_tty
- && !query ("Discard symbol table from `%s'? ",
- symfile_objfile->name))
+ && (symfile_objfile
+ ? !query (_("Discard symbol table from `%s'? "),
+ symfile_objfile->name)
+ : !query (_("Discard symbol table? "))))
error (_("Not confirmed."));
free_all_objfiles ();
{
unsigned long file_crc = 0;
int fd;
- char buffer[8*1024];
+ gdb_byte buffer[8*1024];
int count;
fd = open (name, O_RDONLY | O_BINARY);
}
static char *debug_file_directory = NULL;
+static void
+show_debug_file_directory (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+The directory where separate debug symbols are searched for is \"%s\".\n"),
+ value);
+}
#if ! defined (DEBUG_SUBDIRECTORY)
#define DEBUG_SUBDIRECTORY ".debug"
/* 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--(1) buildargv implements various
- quoting conventions which are undocumented and have little or
- nothing in common with the way things are quoted (or not quoted)
- elsewhere in GDB, (2) options are used, which are not generally
- used in GDB (perhaps "set mapped on", "set readnow on" would be
- better), (3) the order of options matters, which is contrary to GNU
+ the command is rather bizarre:
+
+ 1. The function buildargv implements various quoting conventions
+ which are undocumented and have little or nothing in common with
+ the way things are quoted (or not quoted) elsewhere in GDB.
+
+ 2. Options are used, which are not generally used in GDB (perhaps
+ "set mapped on", "set readnow on" would be better)
+
+ 3. The order of options matters, which is contrary to GNU
conventions (because it is confusing and inconvenient). */
-/* Note: ezannoni 2000-04-17. This function used to have support for
- rombug (see remote-os9k.c). It consisted of a call to target_link()
- (target.c) to get the address of the text segment from the target,
- and pass that to symbol_file_add(). This is no longer supported. */
void
symbol_file_command (char *args, int from_tty)
{
- char **argv;
- char *name = NULL;
- struct cleanup *cleanups;
- int flags = OBJF_USERLOADED;
-
dont_repeat ();
if (args == NULL)
}
else
{
- if ((argv = buildargv (args)) == NULL)
- {
- nomem (0);
- }
+ char **argv = buildargv (args);
+ int flags = OBJF_USERLOADED;
+ struct cleanup *cleanups;
+ char *name = NULL;
+
+ if (argv == NULL)
+ nomem (0);
+
cleanups = make_cleanup_freeargv (argv);
while (*argv != NULL)
{
error (_("unknown option `%s'"), *argv);
else
{
+ symbol_file_add_main_1 (*argv, from_tty, flags);
name = *argv;
-
- symbol_file_add_main_1 (name, from_tty, flags);
}
+
argv++;
}
if (name == NULL)
- {
- error (_("no symbol file name was specified"));
- }
+ error (_("no symbol file name was specified"));
+
do_cleanups (cleanups);
}
}
/* Set the initial language.
- A better solution would be to record the language in the psymtab when reading
- partial symbols, and then use it (if known) to set the language. This would
- be a win for formats that encode the language in an easily discoverable place,
- such as DWARF. For stabs, we can jump through hoops looking for specially
- named symbols or try to intuit the language from the specific type of stabs
- we find, but we can't do that until later when we read in full symbols.
- FIXME. */
+ FIXME: A better solution would be to record the language in the
+ psymtab when reading partial symbols, and then use it (if known) to
+ set the language. This would be a win for formats that encode the
+ language in an easily discoverable place, such as DWARF. For
+ stabs, we can jump through hoops looking for specially named
+ symbols or try to intuit the language from the specific type of
+ stabs we find, but we can't do that until later when we read in
+ full symbols. */
static void
set_initial_language (void)
if (pst != NULL)
{
if (pst->filename != NULL)
- {
- lang = deduce_language_from_filename (pst->filename);
- }
+ lang = deduce_language_from_filename (pst->filename);
+
if (lang == language_unknown)
{
/* Make C the default language */
lang = language_c;
}
+
set_language (lang);
- expected_language = current_language; /* Don't warn the user */
+ expected_language = current_language; /* Don't warn the user. */
}
}
-/* Open file specified by NAME and hand it off to BFD for preliminary
- analysis. Result is 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. */
+/* 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)
int desc;
char *absolute_name;
-
-
- name = tilde_expand (name); /* Returns 1st new malloc'd copy */
+ name = tilde_expand (name); /* Returns 1st new malloc'd copy. */
/* Look down path for it, allocate 2nd new malloc'd copy. */
- desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, name, O_RDONLY | O_BINARY,
- 0, &absolute_name);
+ desc = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, name,
+ O_RDONLY | O_BINARY, 0, &absolute_name);
#if defined(__GO32__) || defined(_WIN32) || defined (__CYGWIN__)
if (desc < 0)
{
make_cleanup (xfree, name);
perror_with_name (name);
}
- xfree (name); /* Free 1st new malloc'd copy */
- name = absolute_name; /* Keep 2nd malloc'd copy in bfd */
- /* It'll be freed in free_objfile(). */
- sym_bfd = bfd_fdopenr (name, gnutarget, desc);
+ /* 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;
+
+ sym_bfd = bfd_fopen (name, gnutarget, FOPEN_RB, desc);
if (!sym_bfd)
{
close (desc);
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 */
+ /* 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 ()));
}
- return (sym_bfd);
+
+ return sym_bfd;
}
-/* Return the section index for the given section name. Return -1 if
- the section was not found. */
+/* Return the section index for SECTION_NAME on OBJFILE. Return -1 if
+ the section was not found. */
+
int
get_section_index (struct objfile *objfile, char *section_name)
{
asection *sect = bfd_get_section_by_name (objfile->obfd, section_name);
+
if (sect)
return sect->index;
else
return -1;
}
-/* Link a new symtab_fns into the global symtab_fns list. Called on gdb
- startup by the _initialize routine in each object file format reader,
- to register information about each format the the reader is prepared
- to handle. */
+/* 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 the reader is prepared to
+ handle. */
void
add_symtab_fns (struct sym_fns *sf)
symtab_fns = sf;
}
-
-/* Initialize to read symbols from the symbol file sym_bfd. It either
- returns or calls error(). The result is an initialized struct sym_fns
- in the objfile structure, that contains cached information about the
- symbol file. */
+/* Initialize OBJFILE to read symbols from its associated BFD. It
+ either returns or calls error(). The result is an initialized
+ struct sym_fns in the objfile structure, that contains cached
+ information about the symbol file. */
static void
find_sym_fns (struct objfile *objfile)
if (our_flavour == bfd_target_srec_flavour
|| our_flavour == bfd_target_ihex_flavour
|| our_flavour == bfd_target_tekhex_flavour)
- return; /* No symbols. */
+ return; /* No symbols. */
for (sf = symtab_fns; sf != NULL; sf = sf->next)
{
return;
}
}
+
error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."),
bfd_get_target (objfile->obfd));
}
\f
+
/* This function runs the load command of our current target. */
static void
performance compares. */
static int download_write_size = 512;
+static void
+show_download_write_size (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+The write size used when downloading a program is %s.\n"),
+ value);
+}
static int validate_download = 0;
/* Callback service function for generic_load (bfd_map_over_sections). */
bfd_size_type size = bfd_get_section_size (asec);
if (size > 0)
{
- char *buffer;
+ gdb_byte *buffer;
struct cleanup *old_chain;
CORE_ADDR lma = bfd_section_lma (abfd, asec) + args->load_offset;
bfd_size_type block_size;
method to the target vector and then use
that. remote.c could implement that method
using the ``qCRC'' packet. */
- char *check = xmalloc (len);
+ gdb_byte *check = xmalloc (len);
struct cleanup *verify_cleanups =
make_cleanup (xfree, check);
{
asection *s;
bfd *loadfile_bfd;
- time_t start_time, end_time; /* Start and end times of download */
+ struct timeval start_time, end_time;
char *filename;
struct cleanup *old_cleanups;
char *offptr;
bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
(void *) &cbdata.total_size);
- start_time = time (NULL);
+ gettimeofday (&start_time, NULL);
bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
- end_time = time (NULL);
+ gettimeofday (&end_time, NULL);
entry = bfd_get_start_address (loadfile_bfd);
ui_out_text (uiout, "Start address ");
others don't (or didn't - perhaps they have all been deleted). */
print_transfer_performance (gdb_stdout, cbdata.data_count,
- cbdata.write_count, end_time - start_time);
+ cbdata.write_count, &start_time, &end_time);
do_cleanups (old_cleanups);
}
report_transfer_performance (unsigned long data_count, time_t start_time,
time_t end_time)
{
- print_transfer_performance (gdb_stdout, data_count,
- end_time - start_time, 0);
+ struct timeval start, end;
+
+ start.tv_sec = start_time;
+ start.tv_usec = 0;
+ end.tv_sec = end_time;
+ end.tv_usec = 0;
+
+ print_transfer_performance (gdb_stdout, data_count, 0, &start, &end);
}
void
print_transfer_performance (struct ui_file *stream,
unsigned long data_count,
unsigned long write_count,
- unsigned long time_count)
+ const struct timeval *start_time,
+ const struct timeval *end_time)
{
+ unsigned long time_count;
+
+ /* 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;
+
ui_out_text (uiout, "Transfer rate: ");
if (time_count > 0)
{
ui_out_field_fmt (uiout, "transfer-rate", "%lu",
- (data_count * 8) / time_count);
+ 1000 * (data_count * 8) / time_count);
ui_out_text (uiout, " bits/sec");
}
else
}
if (reread_one)
- clear_symtab_users ();
+ {
+ clear_symtab_users ();
+ /* At least one objfile has changed, so we can consider that
+ the executable we're debugging has changed too. */
+ observer_notify_executable_changed (NULL);
+ }
+
}
}
static char *ext_args;
+static void
+show_ext_args (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Mapping between filename extension and source language is \"%s\".\n"),
+ value);
+}
static void
set_ext_lang_command (char *args, int from_tty, struct cmd_list_element *e)
{
/* Someday, we should do better than this, by only blowing away
the things that really need to be blown. */
+
+ /* Clear the "current" symtab first, because it is no longer valid.
+ breakpoint_re_set may try to access the current symtab. */
+ clear_current_source_symtab_and_line ();
+
clear_value_history ();
clear_displays ();
clear_internalvars ();
breakpoint_re_set ();
set_default_breakpoint (0, 0, 0, 0);
- clear_current_source_symtab_and_line ();
clear_pc_function_cache ();
if (deprecated_target_new_objfile_hook)
deprecated_target_new_objfile_hook (NULL);
read_target_long_array (CORE_ADDR memaddr, unsigned int *myaddr, int len)
{
/* FIXME (alloca): Not safe if array is very large. */
- char *buf = alloca (len * TARGET_LONG_BYTES);
+ gdb_byte *buf = alloca (len * TARGET_LONG_BYTES);
int i;
read_memory (memaddr, buf, len * TARGET_LONG_BYTES);
= (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
read_target_long_array (cache_ovly_table_base,
- (int *) cache_ovly_table,
+ (unsigned int *) cache_ovly_table,
cache_novlys * 4);
return 1; /* SUCCESS */
{
cache_ovly_region_table_base = SYMBOL_VALUE_ADDRESS (msym);
read_target_long_array (cache_ovly_region_table_base,
- (int *) cache_ovly_region_table,
+ (unsigned int *) cache_ovly_region_table,
cache_novly_regions * 3);
}
else
/* && cache_ovly_table[i][SIZE] == size */ )
{
read_target_long_array (cache_ovly_table_base + i * TARGET_LONG_BYTES,
- (int *) cache_ovly_table[i], 4);
+ (unsigned int *) cache_ovly_table[i], 4);
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 */ )
Set dynamic symbol table reloading multiple times in one run."), _("\
Show dynamic symbol table reloading multiple times in one run."), NULL,
NULL,
- NULL, /* FIXME: i18n: */
+ show_symbol_reloading,
&setlist, &showlist);
add_prefix_cmd ("overlay", class_support, overlay_command,
Show mapping between filename extension and source language."), _("\
Usage: set extension-language .foo bar"),
set_ext_lang_command,
- NULL, /* FIXME: i18n: */
+ show_ext_args,
&setlist, &showlist);
add_info ("extensions", info_ext_lang_command,
limited by the size of the target packet and the memory\n\
cache."),
NULL,
- NULL, /* FIXME: i18n: */
+ show_download_write_size,
&setlist, &showlist);
debug_file_directory = xstrdup (DEBUGDIR);
- c = (add_set_cmd
- ("debug-file-directory", class_support, var_string,
- (char *) &debug_file_directory,
- "Set the directory where separate debug symbols are searched for.\n"
- "Separate debug symbols are first searched for in the same\n"
- "directory as the binary, then in the `" DEBUG_SUBDIRECTORY
- "' subdirectory,\n"
- "and lastly at the path of the directory of the binary with\n"
- "the global debug-file directory prepended\n",
- &setlist));
- deprecated_add_show_from_set (c, &showlist);
- set_cmd_completer (c, filename_completer);
+ add_setshow_optional_filename_cmd ("debug-file-directory", class_support,
+ &debug_file_directory, _("\
+Set the directory where separate debug symbols are searched for."), _("\
+Show the directory where separate debug symbols are searched for."), _("\
+Separate debug symbols are first searched for in the same\n\
+directory as the binary, then in the `" DEBUG_SUBDIRECTORY "' subdirectory,\n\
+and lastly at the path of the directory of the binary with\n\
+the global debug-file directory prepended."),
+ NULL,
+ show_debug_file_directory,
+ &setlist, &showlist);
}
projects / deliverable / binutils-gdb.git / blobdiff