#include "block.h"
#include "observer.h"
#include "exec.h"
+#include "parser-defs.h"
#include <sys/types.h>
#include <fcntl.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,
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;
/* Otherwise, let's try to find a place for the section. */
+ start_addr = (arg->lowest + align - 1) & -align;
+
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)
start_addr = offsets[indx] + bfd_get_section_size (cur_sec);
start_addr = (start_addr + align - 1) & -align;
done = 0;
- continue;
+ break;
}
/* Otherwise, we appear to be OK. So far. */
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;
+ }
+ }
+
+ /* The user might be reloading because the binary has changed. Take
+ this opportunity to check. */
+ reopen_exec_file ();
+ reread_symbols ();
+
target_load (arg, from_tty);
/* After re-loading the executable, we don't really know which
we don't want to run a subprocess. On the other hand, I'm not sure how
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). */
/* Opaque data for load_section_callback. */
struct load_section_data {
unsigned long load_offset;
+ struct load_progress_data *progress_data;
+ VEC(memory_write_request_s) *requests;
+};
+
+/* Opaque data for load_progress. */
+struct load_progress_data {
+ /* Cumulative data. */
unsigned long write_count;
unsigned long data_count;
bfd_size_type total_size;
};
+/* Opaque data for load_progress for a single section. */
+struct load_progress_section_data {
+ struct load_progress_data *cumulative;
+
+ /* Per-section data. */
+ const char *section_name;
+ ULONGEST section_sent;
+ ULONGEST section_size;
+ CORE_ADDR lma;
+ gdb_byte *buffer;
+};
+
+/* Target write callback routine for progress reporting. */
+
+static void
+load_progress (ULONGEST bytes, void *untyped_arg)
+{
+ struct load_progress_section_data *args = untyped_arg;
+ struct load_progress_data *totals;
+
+ if (args == NULL)
+ /* Writing padding data. No easy way to get at the cumulative
+ stats, so just ignore this. */
+ return;
+
+ totals = args->cumulative;
+
+ if (bytes == 0 && args->section_sent == 0)
+ {
+ /* The write is just starting. Let the user know we've started
+ this section. */
+ ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
+ args->section_name, paddr_nz (args->section_size),
+ paddr_nz (args->lma));
+ return;
+ }
+
+ if (validate_download)
+ {
+ /* Broken memories and broken monitors manifest themselves here
+ when bring new computers to life. This doubles already slow
+ downloads. */
+ /* NOTE: cagney/1999-10-18: A more efficient implementation
+ 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);
+ struct cleanup *verify_cleanups = make_cleanup (xfree, check);
+
+ if (target_read_memory (args->lma, check, bytes) != 0)
+ error (_("Download verify read failed at 0x%s"),
+ paddr (args->lma));
+ if (memcmp (args->buffer, check, bytes) != 0)
+ error (_("Download verify compare failed at 0x%s"),
+ paddr (args->lma));
+ do_cleanups (verify_cleanups);
+ }
+ totals->data_count += bytes;
+ args->lma += bytes;
+ args->buffer += bytes;
+ totals->write_count += 1;
+ args->section_sent += bytes;
+ if (quit_flag
+ || (deprecated_ui_load_progress_hook != NULL
+ && deprecated_ui_load_progress_hook (args->section_name,
+ args->section_sent)))
+ error (_("Canceled the download"));
+
+ if (deprecated_show_load_progress != NULL)
+ deprecated_show_load_progress (args->section_name,
+ args->section_sent,
+ args->section_size,
+ totals->data_count,
+ totals->total_size);
+}
+
/* Callback service function for generic_load (bfd_map_over_sections). */
static void
load_section_callback (bfd *abfd, asection *asec, void *data)
{
+ struct memory_write_request *new_request;
struct load_section_data *args = data;
+ struct load_progress_section_data *section_data;
+ bfd_size_type size = bfd_get_section_size (asec);
+ gdb_byte *buffer;
+ const char *sect_name = bfd_get_section_name (abfd, asec);
- if (bfd_get_section_flags (abfd, asec) & SEC_LOAD)
- {
- bfd_size_type size = bfd_get_section_size (asec);
- if (size > 0)
- {
- gdb_byte *buffer;
- struct cleanup *old_chain;
- CORE_ADDR lma = bfd_section_lma (abfd, asec) + args->load_offset;
- bfd_size_type block_size;
- int err;
- const char *sect_name = bfd_get_section_name (abfd, asec);
- bfd_size_type sent;
-
- if (download_write_size > 0 && size > download_write_size)
- block_size = download_write_size;
- else
- block_size = size;
+ if ((bfd_get_section_flags (abfd, asec) & SEC_LOAD) == 0)
+ return;
- buffer = xmalloc (size);
- old_chain = make_cleanup (xfree, buffer);
+ if (size == 0)
+ return;
- /* Is this really necessary? I guess it gives the user something
- to look at during a long download. */
- ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
- sect_name, paddr_nz (size), paddr_nz (lma));
+ 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));
+ 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->baton = section_data;
- bfd_get_section_contents (abfd, asec, buffer, 0, size);
+ buffer = new_request->data;
- sent = 0;
- do
- {
- int len;
- bfd_size_type this_transfer = size - sent;
-
- if (this_transfer >= block_size)
- this_transfer = block_size;
- len = target_write_memory_partial (lma, buffer,
- this_transfer, &err);
- if (err)
- break;
- if (validate_download)
- {
- /* Broken memories and broken monitors manifest
- themselves here when bring new computers to
- life. This doubles already slow downloads. */
- /* NOTE: cagney/1999-10-18: A more efficient
- implementation 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 (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"),
- paddr (lma));
- if (memcmp (buffer, check, len) != 0)
- error (_("Download verify compare failed at 0x%s"),
- paddr (lma));
- do_cleanups (verify_cleanups);
- }
- args->data_count += len;
- lma += len;
- buffer += len;
- args->write_count += 1;
- sent += len;
- if (quit_flag
- || (deprecated_ui_load_progress_hook != NULL
- && deprecated_ui_load_progress_hook (sect_name, sent)))
- error (_("Canceled the download"));
-
- if (deprecated_show_load_progress != NULL)
- deprecated_show_load_progress (sect_name, sent, size,
- args->data_count,
- args->total_size);
- }
- while (sent < size);
+ section_data->cumulative = args->progress_data;
+ section_data->section_name = sect_name;
+ section_data->section_size = size;
+ section_data->lma = new_request->begin;
+ section_data->buffer = buffer;
- if (err != 0)
- error (_("Memory access error while loading section %s."), sect_name);
+ bfd_get_section_contents (abfd, asec, buffer, 0, size);
+}
- do_cleanups (old_chain);
- }
+/* Clean up an entire memory request vector, including load
+ data and progress records. */
+
+static void
+clear_memory_write_data (void *arg)
+{
+ VEC(memory_write_request_s) **vec_p = arg;
+ VEC(memory_write_request_s) *vec = *vec_p;
+ int i;
+ struct memory_write_request *mr;
+
+ for (i = 0; VEC_iterate (memory_write_request_s, vec, i, mr); ++i)
+ {
+ xfree (mr->data);
+ xfree (mr->baton);
}
+ VEC_free (memory_write_request_s, vec);
}
void
generic_load (char *args, int from_tty)
{
- asection *s;
bfd *loadfile_bfd;
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;
+ struct load_progress_data total_progress;
+
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);
- 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. */
+ argv = buildargv (args);
- /* 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)
+ 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."), 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);
}
bfd_map_over_sections (loadfile_bfd, add_section_size_callback,
- (void *) &cbdata.total_size);
+ (void *) &total_progress.total_size);
+
+ bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
gettimeofday (&start_time, NULL);
- bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata);
+ if (target_write_memory_blocks (cbdata.requests, flash_discard,
+ load_progress) != 0)
+ error (_("Load failed"));
gettimeofday (&end_time, NULL);
ui_out_text (uiout, "Start address ");
ui_out_field_fmt (uiout, "address", "0x%s", paddr_nz (entry));
ui_out_text (uiout, ", load size ");
- ui_out_field_fmt (uiout, "load-size", "%lu", cbdata.data_count);
+ 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. */
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, cbdata.data_count,
- cbdata.write_count, &start_time, &end_time);
+ print_transfer_performance (gdb_stdout, total_progress.data_count,
+ total_progress.write_count,
+ &start_time, &end_time);
do_cleanups (old_cleanups);
}
int i;
int expecting_sec_name = 0;
int expecting_sec_addr = 0;
+ char **argv;
struct sect_opt
{
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);
-
- while (*args != '\000')
- {
- /* Any leading spaces? */
- while (isspace (*args))
- args++;
-
- /* Point arg to the beginning of the argument. */
- arg = args;
-
- /* Move args pointer over the argument. */
- while ((*args != '\000') && !isspace (*args))
- args++;
+ argv = buildargv (args);
+ make_cleanup_freeargv (argv);
- /* If there are more arguments, terminate arg and
- proceed past it. */
- if (*args != '\000')
- *args++ = '\000';
+ if (argv == NULL)
+ nomem (0);
- /* 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. */
to load the program. */
sect_opts[section_index].name = ".text";
sect_opts[section_index].value = arg;
- if (++section_index > num_sect_opts)
+ if (++section_index >= num_sect_opts)
{
num_sect_opts *= 2;
sect_opts = ((struct sect_opt *)
{
sect_opts[section_index].value = arg;
expecting_sec_addr = 0;
- if (++section_index > num_sect_opts)
+ if (++section_index >= num_sect_opts)
{
num_sect_opts *= 2;
sect_opts = ((struct sect_opt *)
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
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. */
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_pc_function_cache ();
if (deprecated_target_new_objfile_hook)
deprecated_target_new_objfile_hook (NULL);
+
+ /* Clear globals which might have pointed into a removed objfile.
+ FIXME: It's not clear which of these are supposed to persist
+ between expressions and which ought to be reset each time. */
+ expression_context_block = NULL;
+ innermost_block = NULL;
}
static void
set_cmd_completer (c, filename_completer);
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\
-Load the symbols from FILE, assuming FILE has been dynamically loaded.\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\
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);
+for access from GDB.\n\
+A load OFFSET may also be given."), &cmdlist);
set_cmd_completer (c, filename_completer);
add_setshow_boolean_cmd ("symbol-reloading", class_support,
add_info ("extensions", info_ext_lang_command,
_("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);
add_setshow_optional_filename_cmd ("debug-file-directory", class_support,
&debug_file_directory, _("\