X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsymfile.c;h=8329aa5aa1e7458c2de24fbb2b40e24c03f2b540;hb=a76d924dffcb040b44a2bb5be026f0c974590c30;hp=08ae12d0a6b6bedd7d8b5817e100ad557df5c878;hpb=66bf4b3a03e67c9c38fb7525c6ce25c4f870206a;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/symfile.c b/gdb/symfile.c index 08ae12d0a6..8329aa5aa1 100644 --- a/gdb/symfile.c +++ b/gdb/symfile.c @@ -1,7 +1,8 @@ /* 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. @@ -19,8 +20,8 @@ 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" @@ -48,6 +49,9 @@ #include "readline/readline.h" #include "gdb_assert.h" #include "block.h" +#include "observer.h" +#include "exec.h" +#include "parser-defs.h" #include #include @@ -55,10 +59,8 @@ #include "gdb_stat.h" #include #include +#include -#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, @@ -138,8 +140,6 @@ static int simple_overlay_update_1 (struct obj_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); @@ -162,6 +162,15 @@ int symbol_reloading = SYMBOL_RELOADING_DEFAULT; #else int symbol_reloading = 0; #endif +static void +show_symbol_reloading (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + 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 @@ -448,6 +457,85 @@ init_objfile_sect_indices (struct objfile *objfile) } } +/* 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 @@ -484,6 +572,19 @@ default_symfile_offsets (struct objfile *objfile, (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); @@ -984,8 +1085,10 @@ symbol_file_clear (int from_tty) { 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 (); @@ -1038,7 +1141,7 @@ separate_debug_file_exists (const char *name, unsigned long crc) { 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); @@ -1054,6 +1157,14 @@ separate_debug_file_exists (const char *name, unsigned long crc) } 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" @@ -1142,26 +1253,21 @@ find_separate_debug_file (struct objfile *objfile) /* 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) @@ -1170,10 +1276,14 @@ symbol_file_command (char *args, int from_tty) } 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) { @@ -1183,30 +1293,30 @@ symbol_file_command (char *args, int from_tty) 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) @@ -1218,23 +1328,23 @@ 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) @@ -1243,13 +1353,11 @@ 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) { @@ -1264,11 +1372,13 @@ symfile_bfd_open (char *name) 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); @@ -1280,33 +1390,36 @@ symfile_bfd_open (char *name) 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) @@ -1315,11 +1428,10 @@ 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) @@ -1331,7 +1443,7 @@ 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) { @@ -1341,17 +1453,59 @@ find_sym_fns (struct objfile *objfile) return; } } + error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."), bfd_get_target (objfile->obfd)); } + /* 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; + } + } + + /* 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 @@ -1368,7 +1522,6 @@ load_command (char *arg, int from_tty) 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 int validate_download = 0; /* Callback service function for generic_load (bfd_map_over_sections). */ @@ -1384,139 +1537,194 @@ add_section_size_callback (bfd *abfd, asection *asec, void *data) /* 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) - { - char *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. */ - char *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; - 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; + 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); @@ -1538,19 +1746,23 @@ generic_load (char *args, int from_tty) } bfd_map_over_sections (loadfile_bfd, add_section_size_callback, - (void *) &cbdata.total_size); - - start_time = time (NULL); + (void *) &total_progress.total_size); bfd_map_over_sections (loadfile_bfd, load_section_callback, &cbdata); - end_time = time (NULL); + gettimeofday (&start_time, NULL); + + if (target_write_memory_blocks (cbdata.requests, flash_discard, + load_progress) != 0) + error (_("Load failed")); + + gettimeofday (&end_time, NULL); entry = bfd_get_start_address (loadfile_bfd); 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. */ @@ -1562,8 +1774,9 @@ generic_load (char *args, int from_tty) 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, end_time - start_time); + print_transfer_performance (gdb_stdout, total_progress.data_count, + total_progress.write_count, + &start_time, &end_time); do_cleanups (old_cleanups); } @@ -1578,21 +1791,35 @@ void 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 @@ -1631,6 +1858,7 @@ add_symbol_file_command (char *args, int from_tty) int i; int expecting_sec_name = 0; int expecting_sec_addr = 0; + char **argv; struct sect_opt { @@ -1652,28 +1880,15 @@ add_symbol_file_command (char *args, int from_tty) 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); + argv = buildargv (args); + make_cleanup_freeargv (argv); - 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++; + 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. */ @@ -1687,7 +1902,7 @@ add_symbol_file_command (char *args, int from_tty) 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 *) @@ -1723,7 +1938,7 @@ add_symbol_file_command (char *args, int from_tty) { 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 *) @@ -1736,9 +1951,15 @@ add_symbol_file_command (char *args, int from_tty) error (_("USAGE: add-symbol-file [-mapped] [-readnow] [-s ]*")); } } - 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 @@ -1876,6 +2097,10 @@ reread_symbols (void) 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. */ @@ -1990,7 +2215,13 @@ reread_symbols (void) } 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); + } + } @@ -2088,9 +2319,17 @@ add_filename_language (char *ext, enum language lang) } 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; @@ -2329,15 +2568,23 @@ clear_symtab_users (void) { /* 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); + + /* 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 @@ -3321,7 +3568,7 @@ static void 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); @@ -3361,7 +3608,7 @@ simple_read_overlay_table (void) = (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 */ @@ -3389,7 +3636,7 @@ simple_read_overlay_region_table (void) { 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 @@ -3423,7 +3670,7 @@ simple_overlay_update_1 (struct obj_section *osect) /* && 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 */ ) @@ -3534,101 +3781,92 @@ _initialize_symfile (void) { 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 -s ...]\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 -s ...]\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.")); 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); }