X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Fexec.c;h=f32589b384721979752b3a2f9d3c1f45499b1fd6;hb=50c8a5160c5292ec7fbf1817960d58b15cb6fc5f;hp=1885afd74e19e82a3c0927940b844d0c5c3d57ec;hpb=de90e03d4c19cf5327b4eaea4ad8666a3a1bfad5;p=platform%2Fupstream%2Fbinutils.git diff --git a/gdb/exec.c b/gdb/exec.c index 1885afd..f32589b 100644 --- a/gdb/exec.c +++ b/gdb/exec.c @@ -34,11 +34,10 @@ #include "gdbthread.h" #include "progspace.h" #include "gdb_bfd.h" +#include "gcore.h" #include #include "readline/readline.h" -#include - #include "gdbcore.h" #include @@ -60,10 +59,7 @@ void _initialize_exec (void); /* The target vector for executable files. */ -struct target_ops exec_ops; - -/* True if the exec target is pushed on the stack. */ -static int using_exec_ops; +static struct target_ops exec_ops; /* Whether to open exec and core files read-only or read-write. */ @@ -78,7 +74,7 @@ show_write_files (struct ui_file *file, int from_tty, static void -exec_open (char *args, int from_tty) +exec_open (const char *args, int from_tty) { target_preopen (from_tty); exec_file_attach (args, from_tty); @@ -114,27 +110,18 @@ exec_close (void) static void exec_close_1 (struct target_ops *self) { - using_exec_ops = 0; + struct program_space *ss; + struct cleanup *old_chain; + old_chain = save_current_program_space (); + ALL_PSPACES (ss) { - struct program_space *ss; - struct cleanup *old_chain; - - old_chain = save_current_program_space (); - ALL_PSPACES (ss) - { - set_current_program_space (ss); - - /* Delete all target sections. */ - resize_section_table - (current_target_sections, - -resize_section_table (current_target_sections, 0)); - - exec_close (); - } - - do_cleanups (old_chain); + set_current_program_space (ss); + clear_section_table (current_target_sections); + exec_close (); } + + do_cleanups (old_chain); } void @@ -165,8 +152,16 @@ exec_file_clear (int from_tty) we're supplying the exec pathname late for good reason.) */ void -exec_file_attach (char *filename, int from_tty) +exec_file_attach (const char *filename, int from_tty) { + struct cleanup *cleanups; + + /* First, acquire a reference to the current exec_bfd. We release + this at the end of the function; but acquiring it now lets the + BFD cache return it if this call refers to the same file. */ + gdb_bfd_ref (exec_bfd); + cleanups = make_cleanup_bfd_unref (exec_bfd); + /* Remove any previous exec file. */ exec_close (); @@ -181,7 +176,6 @@ exec_file_attach (char *filename, int from_tty) } else { - struct cleanup *cleanups; char *scratch_pathname, *canonical_pathname; int scratch_chan; struct target_section *sections = NULL, *sections_end = NULL; @@ -204,7 +198,7 @@ exec_file_attach (char *filename, int from_tty) if (scratch_chan < 0) perror_with_name (filename); - cleanups = make_cleanup (xfree, scratch_pathname); + make_cleanup (xfree, scratch_pathname); /* gdb_bfd_open (and its variants) prefers canonicalized pathname for better BFD caching. */ @@ -260,9 +254,10 @@ exec_file_attach (char *filename, int from_tty) /* Tell display code (if any) about the changed file name. */ if (deprecated_exec_file_display_hook) (*deprecated_exec_file_display_hook) (filename); - - do_cleanups (cleanups); } + + do_cleanups (cleanups); + bfd_cache_close_all (); observer_notify_executable_changed (); } @@ -357,15 +352,29 @@ add_to_section_table (bfd *abfd, struct bfd_section *asect, (*table_pp)++; } -int -resize_section_table (struct target_section_table *table, int num_added) +/* See exec.h. */ + +void +clear_section_table (struct target_section_table *table) +{ + xfree (table->sections); + table->sections = table->sections_end = NULL; +} + +/* Resize section table TABLE by ADJUSTMENT. + ADJUSTMENT may be negative, in which case the caller must have already + removed the sections being deleted. + Returns the old size. */ + +static int +resize_section_table (struct target_section_table *table, int adjustment) { int old_count; int new_count; old_count = table->sections_end - table->sections; - new_count = num_added + old_count; + new_count = adjustment + old_count; if (new_count) { @@ -374,10 +383,7 @@ resize_section_table (struct target_section_table *table, int num_added) table->sections_end = table->sections + new_count; } else - { - xfree (table->sections); - table->sections = table->sections_end = NULL; - } + clear_section_table (table); return old_count; } @@ -430,11 +436,8 @@ add_target_sections (void *owner, /* If these are the first file sections we can provide memory from, push the file_stratum target. */ - if (!using_exec_ops) - { - using_exec_ops = 1; - push_target (&exec_ops); - } + if (!target_is_pushed (&exec_ops)) + push_target (&exec_ops); } } @@ -529,7 +532,59 @@ remove_target_sections (void *owner) -VEC(mem_range_s) * +enum target_xfer_status +exec_read_partial_read_only (gdb_byte *readbuf, ULONGEST offset, + ULONGEST len, ULONGEST *xfered_len) +{ + /* It's unduly pedantic to refuse to look at the executable for + read-only pieces; so do the equivalent of readonly regions aka + QTro packet. */ + if (exec_bfd != NULL) + { + asection *s; + bfd_size_type size; + bfd_vma vma; + + for (s = exec_bfd->sections; s; s = s->next) + { + if ((s->flags & SEC_LOAD) == 0 + || (s->flags & SEC_READONLY) == 0) + continue; + + vma = s->vma; + size = bfd_get_section_size (s); + if (vma <= offset && offset < (vma + size)) + { + ULONGEST amt; + + amt = (vma + size) - offset; + if (amt > len) + amt = len; + + amt = bfd_get_section_contents (exec_bfd, s, + readbuf, offset - vma, amt); + + if (amt == 0) + return TARGET_XFER_EOF; + else + { + *xfered_len = amt; + return TARGET_XFER_OK; + } + } + } + } + + /* Indicate failure to find the requested memory block. */ + return TARGET_XFER_E_IO; +} + +/* Appends all read-only memory ranges found in the target section + table defined by SECTIONS and SECTIONS_END, starting at (and + intersected with) MEMADDR for LEN bytes. Returns the augmented + VEC. */ + +static VEC(mem_range_s) * section_table_available_memory (VEC(mem_range_s) *memory, CORE_ADDR memaddr, ULONGEST len, struct target_section *sections, @@ -567,6 +622,60 @@ section_table_available_memory (VEC(mem_range_s) *memory, } enum target_xfer_status +section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset, + ULONGEST len, ULONGEST *xfered_len) +{ + VEC(mem_range_s) *available_memory = NULL; + struct target_section_table *table; + struct cleanup *old_chain; + mem_range_s *r; + int i; + + table = target_get_section_table (&exec_ops); + available_memory = section_table_available_memory (available_memory, + offset, len, + table->sections, + table->sections_end); + + old_chain = make_cleanup (VEC_cleanup(mem_range_s), + &available_memory); + + normalize_mem_ranges (available_memory); + + for (i = 0; + VEC_iterate (mem_range_s, available_memory, i, r); + i++) + { + if (mem_ranges_overlap (r->start, r->length, offset, len)) + { + CORE_ADDR end; + enum target_xfer_status status; + + /* Get the intersection window. */ + end = min (offset + len, r->start + r->length); + + gdb_assert (end - offset <= len); + + if (offset >= r->start) + status = exec_read_partial_read_only (readbuf, offset, + end - offset, + xfered_len); + else + { + *xfered_len = r->start - offset; + status = TARGET_XFER_UNAVAILABLE; + } + do_cleanups (old_chain); + return status; + } + } + do_cleanups (old_chain); + + *xfered_len = len; + return TARGET_XFER_UNAVAILABLE; +} + +enum target_xfer_status section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len, @@ -830,16 +939,12 @@ exec_has_memory (struct target_ops *ops) != current_target_sections->sections_end); } -/* Find mapped memory. */ - -extern void -exec_set_find_memory_regions (int (*func) (find_memory_region_ftype, void *)) +static char * +exec_make_note_section (struct target_ops *self, bfd *obfd, int *note_size) { - exec_ops.to_find_memory_regions = func; + error (_("Can't create a corefile")); } -static char *exec_make_note_section (bfd *, int *); - /* Fill in the exec file target vector. Very few entries need to be defined. */ @@ -852,16 +957,15 @@ init_exec_ops (void) Specify the filename of the executable file."; exec_ops.to_open = exec_open; exec_ops.to_close = exec_close_1; - exec_ops.to_attach = find_default_attach; exec_ops.to_xfer_partial = exec_xfer_partial; exec_ops.to_get_section_table = exec_get_section_table; exec_ops.to_files_info = exec_files_info; exec_ops.to_insert_breakpoint = ignore; exec_ops.to_remove_breakpoint = ignore; - exec_ops.to_create_inferior = find_default_create_inferior; exec_ops.to_stratum = file_stratum; exec_ops.to_has_memory = exec_has_memory; exec_ops.to_make_corefile_notes = exec_make_note_section; + exec_ops.to_find_memory_regions = objfile_find_memory_regions; exec_ops.to_magic = OPS_MAGIC; } @@ -907,9 +1011,3 @@ Show writing into executable and core files."), NULL, add_target_with_completer (&exec_ops, filename_completer); } - -static char * -exec_make_note_section (bfd *obfd, int *note_size) -{ - error (_("Can't create a corefile")); -}