X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fexec.c;h=7de92347f2eee516cb8db2aa6b70a89c7ffd8947;hb=c0e70c624fc7d89f5cf281350692de89a063786f;hp=0b4237ff63cbe948afed8fb8b6ece40983f94185;hpb=e0cc99a62f9ceb9a0db0b5bc28711fd8c82a6151;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/exec.c b/gdb/exec.c index 0b4237ff63..7de92347f2 100644 --- a/gdb/exec.c +++ b/gdb/exec.c @@ -1,6 +1,6 @@ /* Work with executable files, for GDB. - Copyright (C) 1988-2018 Free Software Foundation, Inc. + Copyright (C) 1988-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -29,7 +29,7 @@ #include "completer.h" #include "value.h" #include "exec.h" -#include "observer.h" +#include "observable.h" #include "arch-utils.h" #include "gdbthread.h" #include "progspace.h" @@ -45,18 +45,42 @@ #include #include "solist.h" #include +#include "common/pathstuff.h" void (*deprecated_file_changed_hook) (const char *); -/* Prototypes for local functions */ +static const target_info exec_target_info = { + "exec", + N_("Local exec file"), + N_("Use an executable file as a target.\n\ +Specify the filename of the executable file.") +}; -static void exec_files_info (struct target_ops *); +/* The target vector for executable files. */ -static void init_exec_ops (void); +struct exec_target final : public target_ops +{ + const target_info &info () const override + { return exec_target_info; } -/* The target vector for executable files. */ + strata stratum () const override { return file_stratum; } + + void close () override; + enum target_xfer_status xfer_partial (enum target_object object, + const char *annex, + gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, + ULONGEST *xfered_len) override; + struct target_section_table *get_section_table () override; + void files_info () override; + + bool has_memory () override; + char *make_corefile_notes (bfd *, int *) override; + int find_memory_regions (find_memory_region_ftype func, void *data) override; +}; -static struct target_ops exec_ops; +static exec_target exec_ops; /* Whether to open exec and core files read-only or read-write. */ @@ -71,7 +95,7 @@ show_write_files (struct ui_file *file, int from_tty, static void -exec_open (const char *args, int from_tty) +exec_target_open (const char *args, int from_tty) { target_preopen (from_tty); exec_file_attach (args, from_tty); @@ -104,8 +128,8 @@ exec_close (void) /* This is the target_close implementation. Clears all target sections and closes all executable bfds from all program spaces. */ -static void -exec_close_1 (struct target_ops *self) +void +exec_target::close () { struct program_space *ss; scoped_restore_current_program_space restore_pspace; @@ -118,26 +142,13 @@ exec_close_1 (struct target_ops *self) } } -void -exec_file_clear (int from_tty) -{ - /* Remove exec file. */ - exec_close (); - - if (from_tty) - printf_unfiltered (_("No executable file now.\n")); -} - -/* See exec.h. */ +/* See gdbcore.h. */ void try_open_exec_file (const char *exec_file_host, struct inferior *inf, symfile_add_flags add_flags) { - struct cleanup *old_chain; - struct gdb_exception prev_err = exception_none; - - old_chain = make_cleanup (free_current_contents, &prev_err.message); + struct gdb_exception prev_err; /* exec_file_attach and symbol_file_add_main may throw an error if the file cannot be opened either locally or remotely. @@ -150,40 +161,32 @@ try_open_exec_file (const char *exec_file_host, struct inferior *inf, Even without a symbol file, the remote-based debugging session should continue normally instead of ending abruptly. Hence we catch thrown errors/exceptions in the following code. */ - TRY + try { /* We must do this step even if exec_file_host is NULL, so that exec_file_attach will clear state. */ exec_file_attach (exec_file_host, add_flags & SYMFILE_VERBOSE); } - CATCH (err, RETURN_MASK_ERROR) + catch (gdb_exception_error &err) { if (err.message != NULL) - warning ("%s", err.message); - - prev_err = err; + warning ("%s", err.what ()); - /* Save message so it doesn't get trashed by the catch below. */ - if (err.message != NULL) - prev_err.message = xstrdup (err.message); + prev_err = std::move (err); } - END_CATCH if (exec_file_host != NULL) { - TRY + try { symbol_file_add_main (exec_file_host, add_flags); } - CATCH (err, RETURN_MASK_ERROR) + catch (const gdb_exception_error &err) { if (!exception_print_same (prev_err, err)) - warning ("%s", err.message); + warning ("%s", err.what ()); } - END_CATCH } - - do_cleanups (old_chain); } /* See gdbcore.h. */ @@ -245,7 +248,7 @@ exec_file_attach (const char *filename, int from_tty) /* 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_ptr exec_bfd_holder = new_bfd_ref (exec_bfd); + gdb_bfd_ref_ptr exec_bfd_holder = gdb_bfd_ref_ptr::new_reference (exec_bfd); /* Remove any previous exec file. */ exec_close (); @@ -347,7 +350,7 @@ exec_file_attach (const char *filename, int from_tty) exec_close (); error (_("\"%s\": not in executable format: %s"), scratch_pathname, - gdb_bfd_errmsg (bfd_get_error (), matching)); + gdb_bfd_errmsg (bfd_get_error (), matching).c_str ()); } if (build_section_table (exec_bfd, §ions, §ions_end)) @@ -377,7 +380,7 @@ exec_file_attach (const char *filename, int from_tty) } bfd_cache_close_all (); - observer_notify_executable_changed (); + gdb::observers::executable_changed.notify (); } /* Process the first arg in ARGS as the new exec file. @@ -845,19 +848,19 @@ section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf, return TARGET_XFER_EOF; /* We can't help. */ } -static struct target_section_table * -exec_get_section_table (struct target_ops *ops) +struct target_section_table * +exec_target::get_section_table () { return current_target_sections; } -static enum target_xfer_status -exec_xfer_partial (struct target_ops *ops, enum target_object object, - const char *annex, gdb_byte *readbuf, - const gdb_byte *writebuf, - ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) +enum target_xfer_status +exec_target::xfer_partial (enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) { - struct target_section_table *table = target_get_section_table (ops); + struct target_section_table *table = get_section_table (); if (object == TARGET_OBJECT_MEMORY) return section_table_xfer_memory_partial (readbuf, writebuf, @@ -939,8 +942,8 @@ print_section_info (struct target_section_table *t, bfd *abfd) } } -static void -exec_files_info (struct target_ops *t) +void +exec_target::files_info () { if (exec_bfd) print_section_info (current_target_sections, exec_bfd); @@ -980,7 +983,7 @@ set_section_command (const char *args, int from_tty) p->addr += offset; p->endaddr += offset; if (from_tty) - exec_files_info (&exec_ops); + exec_ops.files_info (); return; } } @@ -1012,29 +1015,8 @@ exec_set_section_address (const char *filename, int index, CORE_ADDR address) } } -/* If mourn is being called in all the right places, this could be say - `gdb internal error' (since generic_mourn calls - breakpoint_init_inferior). */ - -static int -ignore (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) -{ - return 0; -} - -/* Implement the to_remove_breakpoint method. */ - -static int -exec_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt, - enum remove_bp_reason reason) -{ - return 0; -} - -static int -exec_has_memory (struct target_ops *ops) +bool +exec_target::has_memory () { /* We can provide memory if we have any file/target sections to read from. */ @@ -1042,34 +1024,16 @@ exec_has_memory (struct target_ops *ops) != current_target_sections->sections_end); } -static char * -exec_make_note_section (struct target_ops *self, bfd *obfd, int *note_size) +char * +exec_target::make_corefile_notes (bfd *obfd, int *note_size) { error (_("Can't create a corefile")); } -/* Fill in the exec file target vector. Very few entries need to be - defined. */ - -static void -init_exec_ops (void) +int +exec_target::find_memory_regions (find_memory_region_ftype func, void *data) { - exec_ops.to_shortname = "exec"; - exec_ops.to_longname = "Local exec file"; - exec_ops.to_doc = "Use an executable file as a target.\n\ -Specify the filename of the executable file."; - exec_ops.to_open = exec_open; - exec_ops.to_close = exec_close_1; - 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 = exec_remove_breakpoint; - 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; + return objfile_find_memory_regions (this, func, data); } void @@ -1077,8 +1041,6 @@ _initialize_exec (void) { struct cmd_list_element *c; - init_exec_ops (); - if (!dbx_commands) { c = add_cmd ("file", class_files, file_command, _("\ @@ -1112,5 +1074,5 @@ Show writing into executable and core files."), NULL, show_write_files, &setlist, &showlist); - add_target_with_completer (&exec_ops, filename_completer); + add_target (exec_target_info, exec_target_open, filename_completer); }