X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsymfile.c;h=8e4e03d8aa454dc5ee2ebf50f21410aea1f6282c;hb=9f43d28cb0b3e1e8fa7c4017c81b9ef81843ab4d;hp=63dd4b3ee008952dda2eed5dbe9b6d2d38df5cf3;hpb=777ea8f14f3be7147da90d067f72f925ea4f282f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/symfile.c b/gdb/symfile.c index 63dd4b3ee0..8e4e03d8aa 100644 --- a/gdb/symfile.c +++ b/gdb/symfile.c @@ -1,7 +1,7 @@ /* Generic symbol file reading for the GNU debugger, GDB. - Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -51,6 +51,8 @@ #include "block.h" #include "observer.h" #include "exec.h" +#include "parser-defs.h" +#include "varobj.h" #include #include @@ -60,9 +62,6 @@ #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, @@ -72,7 +71,6 @@ void (*deprecated_show_load_progress) (const char *section, unsigned long total_size); void (*deprecated_pre_add_symbol_hook) (const char *); void (*deprecated_post_add_symbol_hook) (void); -void (*deprecated_target_new_objfile_hook) (struct objfile *); static void clear_symtab_users_cleanup (void *ignore); @@ -108,7 +106,7 @@ bfd *symfile_bfd_open (char *); int get_section_index (struct objfile *, char *); -static void find_sym_fns (struct objfile *); +static struct sym_fns *find_sym_fns (bfd *); static void decrement_reading_symtab (void *); @@ -148,6 +146,8 @@ static char *find_separate_debug_file (struct objfile *objfile); static void init_filename_language_table (void); +static void symfile_find_segment_sections (struct objfile *objfile); + void _initialize_symfile (void); /* List of all available sym_fns. On gdb startup, each object file reader @@ -432,12 +432,19 @@ init_objfile_sect_indices (struct objfile *objfile) /* This is where things get really weird... We MUST have valid indices for the various sect_index_* members or gdb will abort. So if for example, there is no ".text" section, we have to - accomodate that. Except when explicitly adding symbol files at - some address, section_offsets contains nothing but zeros, so it - doesn't matter which slot in section_offsets the individual - sect_index_* members index into. So if they are all zero, it is - safe to just point all the currently uninitialized indices to the - first slot. */ + accomodate that. First, check for a file with the standard + one or two segments. */ + + symfile_find_segment_sections (objfile); + + /* Except when explicitly adding symbol files at some address, + section_offsets contains nothing but zeros, so it doesn't matter + which slot in section_offsets the individual sect_index_* members + index into. So if they are all zero, it is safe to just point + all the currently uninitialized indices to the first slot. But + beware: if this is the main executable, it may be relocated + later, e.g. by the remote qOffsets packet, and then this will + be wrong! That's why we try segments first. */ for (i = 0; i < objfile->num_sections; i++) { @@ -476,9 +483,10 @@ 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) + /* We are only interested in allocated sections. */ + if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) return; /* If the user specified an offset, honor it. */ @@ -486,11 +494,11 @@ place_section (bfd *abfd, asection *sect, void *obj) 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) @@ -502,13 +510,8 @@ place_section (bfd *abfd, asection *sect, void *obj) 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) + /* We can only conflict with allocated sections. */ + if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0) continue; /* If the section offset is 0, either the section has not been placed @@ -524,7 +527,7 @@ place_section (bfd *abfd, asection *sect, void *obj) 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. */ @@ -581,9 +584,62 @@ default_symfile_offsets (struct objfile *objfile, 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); + bfd *abfd = objfile->obfd; + asection *cur_sec; + CORE_ADDR lowest = 0; + + for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next) + /* We do not expect this to happen; just skip this step if the + relocatable file has a section with an assigned VMA. */ + if (bfd_section_vma (abfd, cur_sec) != 0) + break; + + if (cur_sec == NULL) + { + CORE_ADDR *offsets = objfile->section_offsets->offsets; + + /* Pick non-overlapping offsets for sections the user did not + place explicitly. */ + arg.offsets = objfile->section_offsets; + arg.lowest = 0; + bfd_map_over_sections (objfile->obfd, place_section, &arg); + + /* Correctly filling in the section offsets is not quite + enough. Relocatable files have two properties that + (most) shared objects do not: + + - Their debug information will contain relocations. Some + shared libraries do also, but many do not, so this can not + be assumed. + + - If there are multiple code sections they will be loaded + at different relative addresses in memory than they are + in the objfile, since all sections in the file will start + at address zero. + + Because GDB has very limited ability to map from an + address in debug info to the correct code section, + it relies on adding SECT_OFF_TEXT to things which might be + code. If we clear all the section offsets, and set the + section VMAs instead, then symfile_relocate_debug_section + will return meaningful debug information pointing at the + correct sections. + + GDB has too many different data structures for section + addresses - a bfd, objfile, and so_list all have section + tables, as does exec_ops. Some of these could probably + be eliminated. */ + + for (cur_sec = abfd->sections; cur_sec != NULL; + cur_sec = cur_sec->next) + { + if ((bfd_get_section_flags (abfd, cur_sec) & SEC_ALLOC) == 0) + continue; + + bfd_set_section_vma (abfd, cur_sec, offsets[cur_sec->index]); + offsets[cur_sec->index] = 0; + } + } } /* Remember the bfd indexes for the .text, .data, .bss and @@ -592,6 +648,70 @@ default_symfile_offsets (struct objfile *objfile, } +/* Divide the file into segments, which are individual relocatable units. + This is the default version of the sym_fns.sym_segments function for + symbol readers that do not have an explicit representation of segments. + It assumes that object files do not have segments, and fully linked + files have a single segment. */ + +struct symfile_segment_data * +default_symfile_segments (bfd *abfd) +{ + int num_sections, i; + asection *sect; + struct symfile_segment_data *data; + CORE_ADDR low, high; + + /* Relocatable files contain enough information to position each + loadable section independently; they should not be relocated + in segments. */ + if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) == 0) + return NULL; + + /* Make sure there is at least one loadable section in the file. */ + for (sect = abfd->sections; sect != NULL; sect = sect->next) + { + if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) + continue; + + break; + } + if (sect == NULL) + return NULL; + + low = bfd_get_section_vma (abfd, sect); + high = low + bfd_get_section_size (sect); + + data = XZALLOC (struct symfile_segment_data); + data->num_segments = 1; + data->segment_bases = XCALLOC (1, CORE_ADDR); + data->segment_sizes = XCALLOC (1, CORE_ADDR); + + num_sections = bfd_count_sections (abfd); + data->segment_info = XCALLOC (num_sections, int); + + for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) + { + CORE_ADDR vma; + + if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) + continue; + + vma = bfd_get_section_vma (abfd, sect); + if (vma < low) + low = vma; + if (vma + bfd_get_section_size (sect) > high) + high = vma + bfd_get_section_size (sect); + + data->segment_info[i] = 1; + } + + data->segment_bases[0] = low; + data->segment_sizes[0] = high - low; + + return data; +} + /* Process a symbol file, as either the main file or as a dynamically loaded file. @@ -638,7 +758,7 @@ syms_from_objfile (struct objfile *objfile, gdb_assert (! (addrs && offsets)); init_entry_point_info (objfile); - find_sym_fns (objfile); + objfile->sf = find_sym_fns (objfile->obfd); if (objfile->sf == NULL) return; /* No symbols. */ @@ -1019,8 +1139,7 @@ symbol_file_add_with_addrs_or_offsets (bfd *abfd, int from_tty, new_symfile_objfile (objfile, mainline, from_tty); - if (deprecated_target_new_objfile_hook) - deprecated_target_new_objfile_hook (objfile); + observer_notify_new_objfile (objfile); bfd_cache_close_all (); return (objfile); @@ -1157,7 +1276,7 @@ separate_debug_file_exists (const char *name, unsigned long crc) return crc == file_crc; } -static char *debug_file_directory = NULL; +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) @@ -1179,6 +1298,7 @@ find_separate_debug_file (struct objfile *objfile) char *dir; char *debugfile; char *name_copy; + char *canon_name; bfd_size_type debuglink_size; unsigned long crc32; int i; @@ -1246,6 +1366,30 @@ find_separate_debug_file (struct objfile *objfile) return xstrdup (debugfile); } + /* If the file is in the sysroot, try using its base path in the + global debugfile directory. */ + canon_name = lrealpath (dir); + if (canon_name + && strncmp (canon_name, gdb_sysroot, strlen (gdb_sysroot)) == 0 + && IS_DIR_SEPARATOR (canon_name[strlen (gdb_sysroot)])) + { + strcpy (debugfile, debug_file_directory); + strcat (debugfile, canon_name + strlen (gdb_sysroot)); + strcat (debugfile, "/"); + strcat (debugfile, basename); + + if (separate_debug_file_exists (debugfile, crc32)) + { + xfree (canon_name); + xfree (basename); + xfree (dir); + return xstrdup (debugfile); + } + } + + if (canon_name) + xfree (canon_name); + xfree (basename); xfree (dir); return NULL; @@ -1434,29 +1578,23 @@ add_symtab_fns (struct sym_fns *sf) struct sym_fns in the objfile structure, that contains cached information about the symbol file. */ -static void -find_sym_fns (struct objfile *objfile) +static struct sym_fns * +find_sym_fns (bfd *abfd) { struct sym_fns *sf; - enum bfd_flavour our_flavour = bfd_get_flavour (objfile->obfd); - char *our_target = bfd_get_target (objfile->obfd); + enum bfd_flavour our_flavour = bfd_get_flavour (abfd); if (our_flavour == bfd_target_srec_flavour || our_flavour == bfd_target_ihex_flavour || our_flavour == bfd_target_tekhex_flavour) - return; /* No symbols. */ + return NULL; /* No symbols. */ for (sf = symtab_fns; sf != NULL; sf = sf->next) - { - if (our_flavour == sf->sym_flavour) - { - objfile->sf = sf; - return; - } - } + if (our_flavour == sf->sym_flavour) + return sf; error (_("I'm sorry, Dave, I can't do that. Symbol format `%s' unknown."), - bfd_get_target (objfile->obfd)); + bfd_get_target (abfd)); } @@ -1466,7 +1604,47 @@ 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 @@ -1483,15 +1661,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 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). */ @@ -1507,139 +1676,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) - { - 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; - 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. */ + make_cleanup (clear_memory_write_data, &cbdata.requests); - /* 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."), 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); @@ -1661,11 +1885,15 @@ generic_load (char *args, int from_tty) } 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); @@ -1673,7 +1901,7 @@ generic_load (char *args, int from_tty) 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. */ @@ -1685,8 +1913,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, &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); } @@ -1718,7 +1947,7 @@ print_transfer_performance (struct ui_file *stream, const struct timeval *start_time, const struct timeval *end_time) { - unsigned long time_count; + ULONGEST time_count; /* Compute the elapsed time in milliseconds, as a tradeoff between accuracy and overflow. */ @@ -1728,9 +1957,23 @@ print_transfer_performance (struct ui_file *stream, ui_out_text (uiout, "Transfer rate: "); if (time_count > 0) { - ui_out_field_fmt (uiout, "transfer-rate", "%lu", - 1000 * (data_count * 8) / time_count); - ui_out_text (uiout, " bits/sec"); + unsigned long rate = ((ULONGEST) data_count * 1000) / time_count; + + if (ui_out_is_mi_like_p (uiout)) + { + ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate * 8); + ui_out_text (uiout, " bits/sec"); + } + else if (rate < 1024) + { + ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate); + ui_out_text (uiout, " bytes/sec"); + } + else + { + ui_out_field_fmt (uiout, "transfer-rate", "%lu", rate / 1024); + ui_out_text (uiout, " KB/sec"); + } } else { @@ -1768,6 +2011,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 { @@ -1789,28 +2033,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); - - 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. */ @@ -1824,7 +2055,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 *) @@ -1860,7 +2091,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 *) @@ -1873,9 +2104,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 @@ -2013,6 +2250,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. */ @@ -2393,14 +2634,6 @@ allocate_symtab (char *filename, struct objfile *objfile) symtab->next = objfile->symtabs; objfile->symtabs = symtab; - /* FIXME: This should go away. It is only defined for the Z8000, - and the Z8000 definition of this macro doesn't have anything to - do with the now-nonexistent EXTRA_SYMTAB_INFO macro, it's just - here for convenience. */ -#ifdef INIT_EXTRA_SYMTAB_INFO - INIT_EXTRA_SYMTAB_INFO (symtab); -#endif - return (symtab); } @@ -2485,14 +2718,21 @@ clear_symtab_users (void) 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); + observer_notify_new_objfile (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; + + /* Varobj may refer to old symbols, perform a cleanup. */ + varobj_invalidate (); + } static void @@ -2790,75 +3030,6 @@ add_psymbol_to_list (char *name, int namelength, domain_enum domain, return psym; } -/* Add a symbol with a long value to a psymtab. This differs from - * add_psymbol_to_list above in taking both a mangled and a demangled - * name. */ - -void -add_psymbol_with_dem_name_to_list (char *name, int namelength, char *dem_name, - int dem_namelength, domain_enum domain, - enum address_class class, - struct psymbol_allocation_list *list, long val, /* Value as a long */ - CORE_ADDR coreaddr, /* Value as a CORE_ADDR */ - enum language language, - struct objfile *objfile) -{ - struct partial_symbol *psym; - char *buf = alloca (namelength + 1); - /* psymbol is static so that there will be no uninitialized gaps in the - structure which might contain random data, causing cache misses in - bcache. */ - static struct partial_symbol psymbol; - - /* Create local copy of the partial symbol */ - - memcpy (buf, name, namelength); - buf[namelength] = '\0'; - DEPRECATED_SYMBOL_NAME (&psymbol) = deprecated_bcache (buf, namelength + 1, - objfile->psymbol_cache); - - buf = alloca (dem_namelength + 1); - memcpy (buf, dem_name, dem_namelength); - buf[dem_namelength] = '\0'; - - switch (language) - { - case language_c: - case language_cplus: - SYMBOL_CPLUS_DEMANGLED_NAME (&psymbol) = - deprecated_bcache (buf, dem_namelength + 1, objfile->psymbol_cache); - break; - /* FIXME What should be done for the default case? Ignoring for now. */ - } - - /* val and coreaddr are mutually exclusive, one of them *will* be zero */ - if (val != 0) - { - SYMBOL_VALUE (&psymbol) = val; - } - else - { - SYMBOL_VALUE_ADDRESS (&psymbol) = coreaddr; - } - SYMBOL_SECTION (&psymbol) = 0; - SYMBOL_LANGUAGE (&psymbol) = language; - PSYMBOL_DOMAIN (&psymbol) = domain; - PSYMBOL_CLASS (&psymbol) = class; - SYMBOL_INIT_LANGUAGE_SPECIFIC (&psymbol, language); - - /* Stash the partial symbol away in the cache */ - psym = deprecated_bcache (&psymbol, sizeof (struct partial_symbol), - objfile->psymbol_cache); - - /* Save pointer to partial symbol in psymtab, growing symtab if needed. */ - if (list->next >= list->list + list->size) - { - extend_psymbol_list (list, objfile); - } - *list->next++ = psym; - OBJSTAT (objfile, n_psyms++); -} - /* Initialize storage for partial symbols. */ void @@ -2952,10 +3123,6 @@ init_psymbol_list (struct objfile *objfile, int total_symbols) enum overlay_debugging_state overlay_debugging = ovly_off; int overlay_cache_invalid = 0; /* True if need to refresh mapped state */ -/* Target vector for refreshing overlay mapped state */ -static void simple_overlay_update (struct obj_section *); -void (*target_overlay_update) (struct obj_section *) = simple_overlay_update; - /* Function: section_is_overlay (SECTION) Returns true if SECTION has VMA not equal to LMA, ie. SECTION is loaded at an address different from where it will "run". */ @@ -3009,9 +3176,9 @@ overlay_is_mapped (struct obj_section *osect) case ovly_off: return 0; /* overlay debugging off */ case ovly_auto: /* overlay debugging automatic */ - /* Unles there is a target_overlay_update function, + /* Unles there is a gdbarch_overlay_update function, there's really nothing useful to do here (can't really go auto) */ - if (target_overlay_update) + if (gdbarch_overlay_update_p (current_gdbarch)) { if (overlay_cache_invalid) { @@ -3019,7 +3186,7 @@ overlay_is_mapped (struct obj_section *osect) overlay_cache_invalid = 0; } if (osect->ovly_mapped == -1) - (*target_overlay_update) (osect); + gdbarch_overlay_update (current_gdbarch, osect); } /* fall thru to manual case */ case ovly_on: /* overlay debugging manual */ @@ -3372,8 +3539,8 @@ overlay_off_command (char *args, int from_tty) static void overlay_load_command (char *args, int from_tty) { - if (target_overlay_update) - (*target_overlay_update) (NULL); + if (gdbarch_overlay_update_p (current_gdbarch)) + gdbarch_overlay_update (current_gdbarch, NULL); else error (_("This target does not know how to read its overlay state.")); } @@ -3397,7 +3564,7 @@ overlay_command (char *args, int from_tty) This is GDB's default target overlay layer. It works with the minimal overlay manager supplied as an example by Cygnus. The - entry point is via a function pointer "target_overlay_update", + entry point is via a function pointer "gdbarch_overlay_update", so targets that use a different runtime overlay manager can substitute their own overlay_update function and take over the function pointer. @@ -3444,7 +3611,8 @@ enum ovly_index { VMA, SIZE, LMA, MAPPED }; -#define TARGET_LONG_BYTES (TARGET_LONG_BIT / TARGET_CHAR_BIT) +#define TARGET_LONG_BYTES (gdbarch_long_bit (current_gdbarch) \ + / TARGET_CHAR_BIT) /* Throw away the cached copy of _ovly_table */ static void @@ -3600,7 +3768,7 @@ simple_overlay_update_1 (struct obj_section *osect) If a cached entry can't be found or the cache isn't valid, then re-read the entire cache, and go ahead and update all sections. */ -static void +void simple_overlay_update (struct obj_section *osect) { struct objfile *objfile; @@ -3684,6 +3852,111 @@ symfile_relocate_debug_section (bfd *abfd, asection *sectp, bfd_byte *buf) return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL); } +struct symfile_segment_data * +get_symfile_segment_data (bfd *abfd) +{ + struct sym_fns *sf = find_sym_fns (abfd); + + if (sf == NULL) + return NULL; + + return sf->sym_segments (abfd); +} + +void +free_symfile_segment_data (struct symfile_segment_data *data) +{ + xfree (data->segment_bases); + xfree (data->segment_sizes); + xfree (data->segment_info); + xfree (data); +} + +int +symfile_map_offsets_to_segments (bfd *abfd, struct symfile_segment_data *data, + struct section_offsets *offsets, + int num_segment_bases, + const CORE_ADDR *segment_bases) +{ + int i; + asection *sect; + + /* If we do not have segment mappings for the object file, we + can not relocate it by segments. */ + gdb_assert (data != NULL); + gdb_assert (data->num_segments > 0); + + /* If more offsets are provided than we have segments, make sure the + excess offsets are all the same as the last segment's offset. + This allows "Text=X;Data=X" for files which have only a single + segment. */ + if (num_segment_bases > data->num_segments) + for (i = data->num_segments; i < num_segment_bases; i++) + if (segment_bases[i] != segment_bases[data->num_segments - 1]) + return 0; + + for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) + { + CORE_ADDR vma; + int which = data->segment_info[i]; + + if (which > num_segment_bases) + offsets->offsets[i] = segment_bases[num_segment_bases - 1]; + else if (which > 0) + offsets->offsets[i] = segment_bases[which - 1]; + else + continue; + + offsets->offsets[i] -= data->segment_bases[which - 1]; + } + + return 1; +} + +static void +symfile_find_segment_sections (struct objfile *objfile) +{ + bfd *abfd = objfile->obfd; + int i; + asection *sect; + struct symfile_segment_data *data; + + data = get_symfile_segment_data (objfile->obfd); + if (data == NULL) + return; + + if (data->num_segments != 1 && data->num_segments != 2) + { + free_symfile_segment_data (data); + return; + } + + for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) + { + CORE_ADDR vma; + int which = data->segment_info[i]; + + if (which == 1) + { + if (objfile->sect_index_text == -1) + objfile->sect_index_text = sect->index; + + if (objfile->sect_index_rodata == -1) + objfile->sect_index_rodata = sect->index; + } + else if (which == 2) + { + if (objfile->sect_index_data == -1) + objfile->sect_index_data = sect->index; + + if (objfile->sect_index_bss == -1) + objfile->sect_index_bss = sect->index; + } + } + + free_symfile_segment_data (data); +} + void _initialize_symfile (void) { @@ -3696,8 +3969,8 @@ to execute."), &cmdlist); 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 -s ...]\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\ @@ -3714,7 +3987,8 @@ Load the symbols from shared objects in the dynamic linker's link map."), 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, @@ -3764,20 +4038,6 @@ Usage: set extension-language .foo bar"), 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, _("\ Set the directory where separate debug symbols are searched for."), _("\