/* 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
-#endif
int (*deprecated_ui_load_progress_hook) (const char *section, unsigned long num);
void (*deprecated_show_load_progress) (const char *section,
static void add_filename_language (char *ext, enum language lang);
-static void set_ext_lang_command (char *args, int from_tty);
-
static void info_ext_lang_command (char *args, int from_tty);
static char *find_separate_debug_file (struct objfile *objfile);
#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
return sap;
}
+
+/* Return a freshly allocated copy of ADDRS. The section names, if
+ any, are also freshly allocated copies of those in ADDRS. */
+struct section_addr_info *
+copy_section_addr_info (struct section_addr_info *addrs)
+{
+ struct section_addr_info *copy
+ = alloc_section_addr_info (addrs->num_sections);
+ int i;
+
+ copy->num_sections = addrs->num_sections;
+ for (i = 0; i < addrs->num_sections; i++)
+ {
+ copy->other[i].addr = addrs->other[i].addr;
+ if (addrs->other[i].name)
+ copy->other[i].name = xstrdup (addrs->other[i].name);
+ else
+ copy->other[i].name = NULL;
+ copy->other[i].sectindex = addrs->other[i].sectindex;
+ }
+
+ return copy;
+}
+
+
+
/* Build (allocate and populate) a section_addr_info struct from
an existing section table. */
}
}
+/* 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;
+ ULONGEST align = ((ULONGEST) 1) << bfd_get_section_alignment (abfd, sect);
+
+ /* 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. */
+ start_addr = (arg->lowest + align - 1) & -align;
+
+ do {
+ asection *cur_sec;
+
+ 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;
+ break;
+ }
+
+ /* 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);
bfd_map_over_sections (objfile->obfd, find_lowest_section,
&lower_sect);
if (lower_sect == NULL)
- warning ("no loadable sections found in added symbol-file %s",
+ warning (_("no loadable sections found in added symbol-file %s"),
objfile->name);
else
if ((bfd_get_section_flags (objfile->obfd, lower_sect) & SEC_CODE) == 0)
- warning ("Lowest section in %s is %s at %s",
+ warning (_("Lowest section in %s is %s at %s"),
objfile->name,
bfd_section_name (objfile->obfd, lower_sect),
paddr (bfd_section_vma (objfile->obfd, lower_sect)));
}
else
{
- warning ("section %s not found in %s",
+ warning (_("section %s not found in %s"),
addrs->other[i].name,
objfile->name);
addrs->other[i].addr = 0;
struct objfile *objfile;
struct partial_symtab *psymtab;
char *debugfile;
- struct section_addr_info *orig_addrs;
+ struct section_addr_info *orig_addrs = NULL;
struct cleanup *my_cleanups;
const char *name = bfd_get_filename (abfd);
&& mainline
&& from_tty
&& !query ("Load new symbol table from \"%s\"? ", name))
- error ("Not confirmed.");
+ error (_("Not confirmed."));
objfile = allocate_objfile (abfd, flags);
discard_cleanups (my_cleanups);
- orig_addrs = alloc_section_addr_info (bfd_count_sections (abfd));
- my_cleanups = make_cleanup (xfree, orig_addrs);
if (addrs)
{
- int i;
- orig_addrs->num_sections = addrs->num_sections;
- for (i = 0; i < addrs->num_sections; i++)
- orig_addrs->other[i] = addrs->other[i];
+ orig_addrs = copy_section_addr_info (addrs);
+ make_cleanup_free_section_addr_info (orig_addrs);
}
/* We either created a new mapped symbol table, mapped an existing
deprecated_pre_add_symbol_hook (name);
else
{
- printf_unfiltered ("Reading symbols from %s...", name);
+ printf_unfiltered (_("Reading symbols from %s..."), name);
wrap_here ("");
gdb_flush (gdb_stdout);
}
{
if (from_tty || info_verbose)
{
- printf_unfiltered ("expanding to full symbols...");
+ printf_unfiltered (_("expanding to full symbols..."));
wrap_here ("");
gdb_flush (gdb_stdout);
}
if (!have_partial_symbols () && !have_full_symbols ())
{
wrap_here ("");
- printf_unfiltered ("(no debugging symbols found)...");
+ printf_filtered (_("(no debugging symbols found)"));
+ if (from_tty || info_verbose)
+ printf_filtered ("...");
+ else
+ printf_filtered ("\n");
wrap_here ("");
}
deprecated_post_add_symbol_hook ();
else
{
- printf_unfiltered ("done.\n");
+ printf_unfiltered (_("done.\n"));
}
}
{
if ((have_full_symbols () || have_partial_symbols ())
&& from_tty
- && !query ("Discard symbol table from `%s'? ",
- symfile_objfile->name))
- error ("Not confirmed.");
+ && (symfile_objfile
+ ? !query (_("Discard symbol table from `%s'? "),
+ symfile_objfile->name)
+ : !query (_("Discard symbol table? "))))
+ error (_("Not confirmed."));
free_all_objfiles ();
/* solib descriptors may have handles to objfiles. Since their
symfile_objfile = NULL;
if (from_tty)
- printf_unfiltered ("No symbol file now.\n");
+ printf_unfiltered (_("No symbol file now.\n"));
}
static char *
{
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)
{
if (strcmp (*argv, "-readnow") == 0)
flags |= OBJF_READNOW;
else if (**argv == '-')
- error ("unknown option `%s'", *argv);
+ 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);
make_cleanup (xfree, name);
- error ("\"%s\": can't open to read symbols: %s.", name,
+ error (_("\"%s\": can't open to read symbols: %s."), name,
bfd_errmsg (bfd_get_error ()));
}
bfd_set_cacheable (sym_bfd, 1);
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,
+ 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.",
+
+ 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
load_command (char *arg, int from_tty)
{
if (arg == NULL)
- arg = get_exec_file (1);
+ {
+ char *parg;
+ int count = 0;
+
+ parg = arg = get_exec_file (1);
+
+ /* Count how many \ " ' tab space there are in the name. */
+ while ((parg = strpbrk (parg, "\\\"'\t ")))
+ {
+ parg++;
+ count++;
+ }
+
+ if (count)
+ {
+ /* We need to quote this string so buildargv can pull it apart. */
+ char *temp = xmalloc (strlen (arg) + count + 1 );
+ char *ptemp = temp;
+ char *prev;
+
+ make_cleanup (xfree, temp);
+
+ prev = parg = arg;
+ while ((parg = strpbrk (parg, "\\\"'\t ")))
+ {
+ strncpy (ptemp, prev, parg - prev);
+ ptemp += parg - prev;
+ prev = parg++;
+ *ptemp++ = '\\';
+ }
+ strcpy (ptemp, prev);
+
+ arg = temp;
+ }
+ }
+
target_load (arg, from_tty);
/* After re-loading the executable, we don't really know which
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);
if (target_read_memory (lma, check, len) != 0)
- error ("Download verify read failed at 0x%s",
+ error (_("Download verify read failed at 0x%s"),
paddr (lma));
if (memcmp (buffer, check, len) != 0)
- error ("Download verify compare failed at 0x%s",
+ error (_("Download verify compare failed at 0x%s"),
paddr (lma));
do_cleanups (verify_cleanups);
}
if (quit_flag
|| (deprecated_ui_load_progress_hook != NULL
&& deprecated_ui_load_progress_hook (sect_name, sent)))
- error ("Canceled the download");
+ error (_("Canceled the download"));
if (deprecated_show_load_progress != NULL)
deprecated_show_load_progress (sect_name, sent, size,
while (sent < size);
if (err != 0)
- error ("Memory access error while loading section %s.", sect_name);
+ error (_("Memory access error while loading section %s."), sect_name);
do_cleanups (old_chain);
}
{
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;
+ struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
struct load_section_data cbdata;
CORE_ADDR entry;
+ char **argv;
cbdata.load_offset = 0; /* Offset to add to vma for each section. */
cbdata.write_count = 0; /* Number of writes needed. */
cbdata.data_count = 0; /* Number of bytes written to target memory. */
cbdata.total_size = 0; /* Total size of all bfd sectors. */
- /* Parse the input argument - the user can specify a load offset as
- a second argument. */
- filename = xmalloc (strlen (args) + 1);
- old_cleanups = make_cleanup (xfree, filename);
- strcpy (filename, args);
- offptr = strchr (filename, ' ');
- if (offptr != NULL)
+ argv = buildargv (args);
+
+ if (argv == NULL)
+ nomem(0);
+
+ make_cleanup_freeargv (argv);
+
+ filename = tilde_expand (argv[0]);
+ make_cleanup (xfree, filename);
+
+ if (argv[1] != NULL)
{
char *endptr;
- cbdata.load_offset = strtoul (offptr, &endptr, 0);
- if (offptr == endptr)
- error ("Invalid download offset:%s\n", offptr);
- *offptr = '\0';
+ cbdata.load_offset = strtoul (argv[1], &endptr, 0);
+
+ /* If the last word was not a valid number then
+ treat it as a file name with spaces in. */
+ if (argv[1] == endptr)
+ error (_("Invalid download offset:%s."), argv[1]);
+
+ if (argv[2] != NULL)
+ error (_("Too many parameters."));
}
- else
- cbdata.load_offset = 0;
/* Open the file for loading. */
loadfile_bfd = bfd_openr (filename, gnutarget);
if (!bfd_check_format (loadfile_bfd, bfd_object))
{
- error ("\"%s\" is not an object file: %s", filename,
+ error (_("\"%s\" is not an object file: %s"), filename,
bfd_errmsg (bfd_get_error ()));
}
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
int i;
int expecting_sec_name = 0;
int expecting_sec_addr = 0;
+ char **argv;
struct sect_opt
{
dont_repeat ();
if (args == NULL)
- error ("add-symbol-file takes a file name and an address");
-
- /* Make a copy of the string that we can safely write into. */
- args = xstrdup (args);
+ error (_("add-symbol-file takes a file name and an address"));
- while (*args != '\000')
- {
- /* Any leading spaces? */
- while (isspace (*args))
- args++;
-
- /* Point arg to the beginning of the argument. */
- arg = args;
+ argv = buildargv (args);
+ make_cleanup_freeargv (argv);
- /* Move args pointer over the argument. */
- while ((*args != '\000') && !isspace (*args))
- args++;
+ if (argv == NULL)
+ nomem (0);
- /* If there are more arguments, terminate arg and
- proceed past it. */
- if (*args != '\000')
- *args++ = '\000';
-
- /* Now process the argument. */
+ for (arg = argv[0], argcnt = 0; arg != NULL; arg = argv[++argcnt])
+ {
+ /* Process the argument. */
if (argcnt == 0)
{
/* The first argument is the file name. */
}
}
else
- error ("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*");
+ error (_("USAGE: add-symbol-file <filename> <textaddress> [-mapped] [-readnow] [-s <secname> <addr>]*"));
}
}
- argcnt++;
}
+ /* 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);
+
/* Print the prompt for the query below. And save the arguments into
a sect_addr_info structure to be passed around to other
functions. We have to split this up into separate print
- statements because local_hex_string returns a local static
+ statements because hex_string returns a local static
string. */
- printf_unfiltered ("add symbol table from file \"%s\" at\n", filename);
+ printf_unfiltered (_("add symbol table from file \"%s\" at\n"), filename);
section_addrs = alloc_section_addr_info (section_index);
make_cleanup (xfree, section_addrs);
for (i = 0; i < section_index; i++)
section_addrs->other[sec_num].name = sec;
section_addrs->other[sec_num].addr = addr;
printf_unfiltered ("\t%s_addr = %s\n",
- sec,
- local_hex_string ((unsigned long)addr));
+ sec, hex_string ((unsigned long)addr));
sec_num++;
/* The object's sections are initialized when a
}
if (from_tty && (!query ("%s", "")))
- error ("Not confirmed.");
+ error (_("Not confirmed."));
symbol_file_add (filename, from_tty, section_addrs, 0, flags);
#ifdef ADD_SHARED_SYMBOL_FILES
ADD_SHARED_SYMBOL_FILES (args, from_tty);
#else
- error ("This command is not available in this configuration of GDB.");
+ error (_("This command is not available in this configuration of GDB."));
#endif
}
\f
if (res != 0)
{
/* FIXME, should use print_sys_errmsg but it's not filtered. */
- printf_unfiltered ("`%s' has disappeared; keeping its symbols.\n",
+ printf_unfiltered (_("`%s' has disappeared; keeping its symbols.\n"),
objfile->name);
continue;
}
int num_offsets;
char *obfd_filename;
- printf_unfiltered ("`%s' has changed; re-reading symbols.\n",
+ printf_unfiltered (_("`%s' has changed; re-reading symbols.\n"),
objfile->name);
/* There are various functions like symbol_file_add,
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,
+ error (_("Can't close BFD for %s: %s"), objfile->name,
bfd_errmsg (bfd_get_error ()));
objfile->obfd = bfd_openr (obfd_filename, gnutarget);
if (objfile->obfd == NULL)
- error ("Can't open %s to read symbols.", objfile->name);
+ error (_("Can't open %s to read symbols."), objfile->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,
+ error (_("Can't read symbols from %s: %s."), objfile->name,
bfd_errmsg (bfd_get_error ()));
/* Save the offsets, we will nuke them with the rest of the
memcpy (offsets, objfile->section_offsets,
SIZEOF_N_SECTION_OFFSETS (num_offsets));
+ /* Remove any references to this objfile in the global
+ value lists. */
+ preserve_values (objfile);
+
/* Nuke all the state that we will re-read. Much of the following
code which sets things to NULL really is necessary to tell
other parts of GDB that there is nothing currently there. */
/* FIXME: Do we have to free a whole linked list, or is this
enough? */
if (objfile->global_psymbols.list)
- xmfree (objfile->md, objfile->global_psymbols.list);
+ xfree (objfile->global_psymbols.list);
memset (&objfile->global_psymbols, 0,
sizeof (objfile->global_psymbols));
if (objfile->static_psymbols.list)
- xmfree (objfile->md, objfile->static_psymbols.list);
+ xfree (objfile->static_psymbols.list);
memset (&objfile->static_psymbols, 0,
sizeof (objfile->static_psymbols));
objfile->free_psymtabs = NULL;
objfile->cp_namespace_symtab = NULL;
objfile->msymbols = NULL;
- objfile->sym_private = NULL;
+ objfile->deprecated_sym_private = NULL;
objfile->minimal_symbol_count = 0;
memset (&objfile->msymbol_hash, 0,
sizeof (objfile->msymbol_hash));
obstack_init (&objfile->objfile_obstack);
if (build_objfile_section_table (objfile))
{
- error ("Can't find the file sections in `%s': %s",
+ error (_("Can't find the file sections in `%s': %s"),
objfile->name, bfd_errmsg (bfd_get_error ()));
}
terminate_minimal_symbol_table (objfile);
if (!have_partial_symbols () && !have_full_symbols ())
{
wrap_here ("");
- printf_unfiltered ("(no debugging symbols found)\n");
+ printf_unfiltered (_("(no debugging symbols found)\n"));
wrap_here ("");
}
objfile->flags |= OBJF_SYMS;
}
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)
+set_ext_lang_command (char *args, int from_tty, struct cmd_list_element *e)
{
int i;
char *cp = ext_args;
/* First arg is filename extension, starting with '.' */
if (*cp != '.')
- error ("'%s': Filename extension must begin with '.'", ext_args);
+ error (_("'%s': Filename extension must begin with '.'"), ext_args);
/* Find end of first arg. */
while (*cp && !isspace (*cp))
cp++;
if (*cp == '\0')
- error ("'%s': two arguments required -- filename extension and language",
+ error (_("'%s': two arguments required -- filename extension and language"),
ext_args);
/* Null-terminate first arg */
cp++;
if (*cp == '\0')
- error ("'%s': two arguments required -- filename extension and language",
+ error (_("'%s': two arguments required -- filename extension and language"),
ext_args);
/* Lookup the language from among those we know. */
{
int i;
- printf_filtered ("Filename extensions and the languages they represent:");
+ 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",
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);
}
}
{
/* Someday, we should do better than this, by only blowing away
the things that really need to be blown. */
- clear_value_history ();
+
+ /* 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_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);
|| BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
|| BLOCK_NSYMS (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)))
{
- complaint (&symfile_complaints, "Replacing old symbols for `%s'",
+ complaint (&symfile_complaints, _("Replacing old symbols for `%s'"),
name);
clear_symtab_users_queued++;
make_cleanup (clear_symtab_users_once, 0);
blewit = 1;
}
else
- {
- complaint (&symfile_complaints, "Empty symbol table found for `%s'",
- name);
- }
+ complaint (&symfile_complaints, _("Empty symbol table found for `%s'"),
+ name);
free_symtab (s);
}
if (objfile->global_psymbols.list)
{
- xmfree (objfile->md, objfile->global_psymbols.list);
+ xfree (objfile->global_psymbols.list);
}
if (objfile->static_psymbols.list)
{
- xmfree (objfile->md, objfile->static_psymbols.list);
+ xfree (objfile->static_psymbols.list);
}
/* Current best guess is that approximately a twentieth
{
objfile->global_psymbols.next =
objfile->global_psymbols.list = (struct partial_symbol **)
- xmmalloc (objfile->md, (objfile->global_psymbols.size
- * sizeof (struct partial_symbol *)));
+ xmalloc ((objfile->global_psymbols.size
+ * sizeof (struct partial_symbol *)));
}
if (objfile->static_psymbols.size > 0)
{
objfile->static_psymbols.next =
objfile->static_psymbols.list = (struct partial_symbol **)
- xmmalloc (objfile->md, (objfile->static_psymbols.size
- * sizeof (struct partial_symbol *)));
+ xmalloc ((objfile->static_psymbols.size
+ * sizeof (struct partial_symbol *)));
}
}
name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
printf_filtered ("Section %s, loaded at ", name);
- print_address_numeric (lma, 1, gdb_stdout);
+ deprecated_print_address_numeric (lma, 1, gdb_stdout);
puts_filtered (" - ");
- print_address_numeric (lma + size, 1, gdb_stdout);
+ deprecated_print_address_numeric (lma + size, 1, gdb_stdout);
printf_filtered (", mapped at ");
- print_address_numeric (vma, 1, gdb_stdout);
+ deprecated_print_address_numeric (vma, 1, gdb_stdout);
puts_filtered (" - ");
- print_address_numeric (vma + size, 1, gdb_stdout);
+ deprecated_print_address_numeric (vma + size, 1, gdb_stdout);
puts_filtered ("\n");
nmapped++;
}
if (nmapped == 0)
- printf_filtered ("No sections are mapped.\n");
+ printf_filtered (_("No sections are mapped.\n"));
}
/* Function: map_overlay_command
asection *bfdsec;
if (!overlay_debugging)
- error ("\
+ error (_("\
Overlay debugging not enabled. Use either the 'overlay auto' or\n\
-the 'overlay manual' command.");
+the 'overlay manual' command."));
if (args == 0 || *args == 0)
- error ("Argument required: name of an overlay section");
+ error (_("Argument required: name of an overlay section"));
/* First, find a section matching the user supplied argument */
ALL_OBJSECTIONS (objfile, sec)
sec2->the_bfd_section))
{
if (info_verbose)
- printf_unfiltered ("Note: section %s unmapped by overlap\n",
+ printf_unfiltered (_("Note: section %s unmapped by overlap\n"),
bfd_section_name (objfile->obfd,
sec2->the_bfd_section));
sec2->ovly_mapped = 0; /* sec2 overlaps sec: unmap sec2 */
}
return;
}
- error ("No overlay section called %s", args);
+ error (_("No overlay section called %s"), args);
}
/* Function: unmap_overlay_command
struct obj_section *sec;
if (!overlay_debugging)
- error ("\
+ error (_("\
Overlay debugging not enabled. Use either the 'overlay auto' or\n\
-the 'overlay manual' command.");
+the 'overlay manual' command."));
if (args == 0 || *args == 0)
- error ("Argument required: name of an overlay section");
+ error (_("Argument required: name of an overlay section"));
/* First, find a section matching the user supplied argument */
ALL_OBJSECTIONS (objfile, sec)
if (!strcmp (bfd_section_name (objfile->obfd, sec->the_bfd_section), args))
{
if (!sec->ovly_mapped)
- error ("Section %s is not mapped", args);
+ error (_("Section %s is not mapped"), args);
sec->ovly_mapped = 0;
return;
}
- error ("No overlay section called %s", args);
+ error (_("No overlay section called %s"), args);
}
/* Function: overlay_auto_command
overlay_debugging = ovly_auto;
enable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered ("Automatic overlay debugging enabled.");
+ printf_unfiltered (_("Automatic overlay debugging enabled."));
}
/* Function: overlay_manual_command
overlay_debugging = ovly_on;
disable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered ("Overlay debugging enabled.");
+ printf_unfiltered (_("Overlay debugging enabled."));
}
/* Function: overlay_off_command
overlay_debugging = ovly_off;
disable_overlay_breakpoints ();
if (info_verbose)
- printf_unfiltered ("Overlay debugging disabled.");
+ printf_unfiltered (_("Overlay debugging disabled."));
}
static void
if (target_overlay_update)
(*target_overlay_update) (NULL);
else
- error ("This target does not know how to read its overlay state.");
+ error (_("This target does not know how to read its overlay state."));
}
/* Function: overlay_command
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);
novlys_msym = lookup_minimal_symbol ("_novlys", NULL, NULL);
if (! novlys_msym)
{
- error ("Error reading inferior's overlay table: "
+ error (_("Error reading inferior's overlay table: "
"couldn't find `_novlys' variable\n"
- "in inferior. Use `overlay manual' mode.");
+ "in inferior. Use `overlay manual' mode."));
return 0;
}
ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, NULL);
if (! ovly_table_msym)
{
- error ("Error reading inferior's overlay table: couldn't find "
+ error (_("Error reading inferior's overlay table: couldn't find "
"`_ovly_table' array\n"
- "in inferior. Use `overlay manual' mode.");
+ "in inferior. Use `overlay manual' mode."));
return 0;
}
= (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 */ )
{
struct cmd_list_element *c;
- c = add_cmd ("symbol-file", class_files, symbol_file_command,
- "Load symbol table from executable file FILE.\n\
+ 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\
-to execute.", &cmdlist);
+to execute."), &cmdlist);
set_cmd_completer (c, filename_completer);
- c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command,
- "Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
-Load the symbols from FILE, assuming FILE has been dynamically loaded.\n\
+ c = add_cmd ("add-symbol-file", class_files, add_symbol_file_command, _("\
+Load symbols from FILE, assuming FILE has been dynamically loaded.\n\
+Usage: add-symbol-file FILE ADDR [-s <SECT> <SECT_ADDR> -s <SECT> <SECT_ADDR> ...]\n\
ADDR is the starting address of the file's text.\n\
The optional arguments are section-name section-address pairs and\n\
should be specified if the data and bss segments are not contiguous\n\
-with the text. SECT is a section name to be loaded at SECT_ADDR.",
+with the text. SECT is a section name to be loaded at SECT_ADDR."),
&cmdlist);
set_cmd_completer (c, filename_completer);
c = add_cmd ("add-shared-symbol-files", class_files,
- add_shared_symbol_files_command,
- "Load the symbols from shared objects in the dynamic linker's link map.",
+ add_shared_symbol_files_command, _("\
+Load the symbols from shared objects in the dynamic linker's link map."),
&cmdlist);
c = add_alias_cmd ("assf", "add-shared-symbol-files", class_files, 1,
&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.", &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);
set_cmd_completer (c, filename_completer);
- deprecated_add_show_from_set
- (add_set_cmd ("symbol-reloading", class_support, var_boolean,
- (char *) &symbol_reloading,
- "Set dynamic symbol table reloading multiple times in one run.",
- &setlist),
- &showlist);
+ 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,
+ _("Commands for debugging overlays."), &overlaylist,
"overlay ", 0, &cmdlist);
add_com_alias ("ovly", "overlay", class_alias, 1);
add_com_alias ("ov", "overlay", class_alias, 1);
add_cmd ("map-overlay", class_support, map_overlay_command,
- "Assert that an overlay section is mapped.", &overlaylist);
+ _("Assert that an overlay section is mapped."), &overlaylist);
add_cmd ("unmap-overlay", class_support, unmap_overlay_command,
- "Assert that an overlay section is unmapped.", &overlaylist);
+ _("Assert that an overlay section is unmapped."), &overlaylist);
add_cmd ("list-overlays", class_support, list_overlays_command,
- "List mappings of overlay sections.", &overlaylist);
+ _("List mappings of overlay sections."), &overlaylist);
add_cmd ("manual", class_support, overlay_manual_command,
- "Enable overlay debugging.", &overlaylist);
+ _("Enable overlay debugging."), &overlaylist);
add_cmd ("off", class_support, overlay_off_command,
- "Disable overlay debugging.", &overlaylist);
+ _("Disable overlay debugging."), &overlaylist);
add_cmd ("auto", class_support, overlay_auto_command,
- "Enable automatic overlay debugging.", &overlaylist);
+ _("Enable automatic overlay debugging."), &overlaylist);
add_cmd ("load-target", class_support, overlay_load_command,
- "Read the overlay mapping state from the target.", &overlaylist);
+ _("Read the overlay mapping state from the target."), &overlaylist);
/* Filename extension to source language lookup table: */
init_filename_language_table ();
- c = add_set_cmd ("extension-language", class_files, var_string_noescape,
- (char *) &ext_args,
- "Set mapping between filename extension and source language.\n\
-Usage: set extension-language .foo bar",
- &setlist);
- set_cmd_cfunc (c, set_ext_lang_command);
+ add_setshow_string_noescape_cmd ("extension-language", class_files,
+ &ext_args, _("\
+Set mapping between filename extension and source language."), _("\
+Show mapping between filename extension and source language."), _("\
+Usage: set extension-language .foo bar"),
+ set_ext_lang_command,
+ show_ext_args,
+ &setlist, &showlist);
add_info ("extensions", info_ext_lang_command,
- "All filename extensions associated with a source language.");
-
- deprecated_add_show_from_set
- (add_set_cmd ("download-write-size", class_obscure,
- var_integer, (char *) &download_write_size,
- "Set the write size used when downloading a program.\n"
- "Only used when downloading a program onto a remote\n"
- "target. Specify zero, or a negative value, to disable\n"
- "blocked writes. The actual size of each transfer is also\n"
- "limited by the size of the target packet and the memory\n"
- "cache.\n",
- &setlist),
- &showlist);
+ _("All filename extensions associated with a source language."));
+
+ add_setshow_integer_cmd ("download-write-size", class_obscure,
+ &download_write_size, _("\
+Set the write size used when downloading a program."), _("\
+Show the write size used when downloading a program."), _("\
+Only used when downloading a program onto a remote\n\
+target. Specify zero, or a negative value, to disable\n\
+blocked writes. The actual size of each transfer is also\n\
+limited by the size of the target packet and the memory\n\
+cache."),
+ NULL,
+ 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