X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fexec.c;h=1c3c16c053e9e7bc78bfeb1c9a930cd96bbd9793;hb=d55e5aa6b29906346c51ad00e6a9b112590aa294;hp=15f85a278ff4d7679153a4d2d19cb5fd12ec1004;hpb=797bc1cb25b9dbdbc663cf711aecb0acc2450276;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/exec.c b/gdb/exec.c
index 15f85a278f..1c3c16c053 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.
 
@@ -18,44 +18,73 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
+
+/* Standard C includes.  */
+#include <ctype.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+/* Standard C++ includes.  */
+#include <algorithm>
+
+/* Local non-gdb includes.  */
+#include "arch-utils.h"
+#include "common/pathstuff.h"
+#include "completer.h"
+#include "exec.h"
+#include "filenames.h"
 #include "frame.h"
-#include "inferior.h"
-#include "target.h"
+#include "gcore.h"
+#include "gdb_bfd.h"
 #include "gdbcmd.h"
+#include "gdbcore.h"
+#include "gdbthread.h"
+#include "inferior.h"
 #include "language.h"
-#include "filenames.h"
-#include "symfile.h"
 #include "objfiles.h"
-#include "completer.h"
-#include "value.h"
-#include "exec.h"
-#include "observer.h"
-#include "arch-utils.h"
-#include "gdbthread.h"
+#include "observable.h"
 #include "progspace.h"
-#include "gdb_bfd.h"
-#include "gcore.h"
-
-#include <fcntl.h>
 #include "readline/readline.h"
-#include "gdbcore.h"
-
-#include <ctype.h>
-#include <sys/stat.h>
 #include "solist.h"
-#include <algorithm>
+#include "source.h"
+#include "symfile.h"
+#include "target.h"
+#include "value.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.")
+};
+
+/* The target vector for executable files.  */
+
+struct exec_target final : public target_ops
+{
+  const target_info &info () const override
+  { return exec_target_info; }
 
-static void exec_files_info (struct target_ops *);
+  strata stratum () const override { return file_stratum; }
 
-static void init_exec_ops (void);
+  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;
 
-/* The target vector for executable files.  */
+  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.  */
 
@@ -70,7 +99,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);
@@ -103,8 +132,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;
@@ -117,27 +146,14 @@ 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);
-
   /* exec_file_attach and symbol_file_add_main may throw an error if the file
      cannot be opened either locally or remotely.
 
@@ -149,6 +165,7 @@ 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.  */
+  std::string saved_message;
   TRY
     {
       /* We must do this step even if exec_file_host is NULL, so that
@@ -164,7 +181,10 @@ try_open_exec_file (const char *exec_file_host, struct inferior *inf,
 
       /* Save message so it doesn't get trashed by the catch below.  */
       if (err.message != NULL)
-	prev_err.message = xstrdup (err.message);
+	{
+	  saved_message = err.message;
+	  prev_err.message = saved_message.c_str ();
+	}
     }
   END_CATCH
 
@@ -181,8 +201,6 @@ try_open_exec_file (const char *exec_file_host, struct inferior *inf,
 	}
       END_CATCH
     }
-
-  do_cleanups (old_chain);
 }
 
 /* See gdbcore.h.  */
@@ -244,7 +262,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 ();
@@ -289,12 +307,10 @@ exec_file_attach (const char *filename, int from_tty)
 	}
       else
 	{
-	  char *temp_pathname;
-
 	  scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
 				filename, write_files ?
 				O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
-				&temp_pathname);
+				&scratch_storage);
 #if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
 	  if (scratch_chan < 0)
 	    {
@@ -305,14 +321,13 @@ exec_file_attach (const char *filename, int from_tty)
 				    exename, write_files ?
 				    O_RDWR | O_BINARY
 				    : O_RDONLY | O_BINARY,
-				    &temp_pathname);
+				    &scratch_storage);
 	    }
 #endif
 	  if (scratch_chan < 0)
 	    perror_with_name (filename);
 
-	  scratch_storage.reset (temp_pathname);
-	  scratch_pathname = temp_pathname;
+	  scratch_pathname = scratch_storage.get ();
 
 	  /* gdb_bfd_open (and its variants) prefers canonicalized
 	     pathname for better BFD caching.  */
@@ -349,7 +364,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, &sections, &sections_end))
@@ -379,7 +394,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.
@@ -847,19 +862,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,
@@ -941,8 +956,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);
@@ -982,7 +997,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;
 	}
     }
@@ -1014,29 +1029,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.  */
@@ -1044,34 +1038,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
@@ -1079,8 +1055,6 @@ _initialize_exec (void)
 {
   struct cmd_list_element *c;
 
-  init_exec_ops ();
-
   if (!dbx_commands)
     {
       c = add_cmd ("file", class_files, file_command, _("\
@@ -1114,5 +1088,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);
 }