X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fcli%2Fcli-dump.c;h=96302615d04e3e6e08d8d1771efbc26b285347c2;hb=995816ba55d952b2823d2ead66495c5cad6dfe58;hp=9e202b6eaf659d2c0d40dbd3fee89191f4e8d0ca;hpb=db229724662fbf62607db43232fcaa3745579a52;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/cli/cli-dump.c b/gdb/cli/cli-dump.c
index 9e202b6eaf..96302615d0 100644
--- a/gdb/cli/cli-dump.c
+++ b/gdb/cli/cli-dump.c
@@ -1,6 +1,6 @@
 /* Dump-to-file commands, for GDB, the GNU debugger.
 
-   Copyright (C) 2002-2013 Free Software Foundation, Inc.
+   Copyright (C) 2002-2017 Free Software Foundation, Inc.
 
    Contributed by Red Hat.
 
@@ -20,12 +20,10 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
-#include "gdb_string.h"
 #include "cli/cli-decode.h"
 #include "cli/cli-cmds.h"
 #include "value.h"
 #include "completer.h"
-#include "gdb_assert.h"
 #include <ctype.h>
 #include "target.h"
 #include "readline/readline.h"
@@ -34,11 +32,9 @@
 #include "gdb_bfd.h"
 #include "filestuff.h"
 
-#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
 
-
-static char *
-scan_expression_with_cleanup (char **cmd, const char *def)
+static const char *
+scan_expression_with_cleanup (const char **cmd, const char *def)
 {
   if ((*cmd) == NULL || (**cmd) == '\0')
     {
@@ -50,19 +46,19 @@ scan_expression_with_cleanup (char **cmd, const char *def)
   else
     {
       char *exp;
-      char *end;
+      const char *end;
 
       end = (*cmd) + strcspn (*cmd, " \t");
       exp = savestring ((*cmd), end - (*cmd));
       make_cleanup (xfree, exp);
-      (*cmd) = skip_spaces (end);
+      (*cmd) = skip_spaces_const (end);
       return exp;
     }
 }
 
 
 static char *
-scan_filename_with_cleanup (char **cmd, const char *defname)
+scan_filename_with_cleanup (const char **cmd, const char *defname)
 {
   char *filename;
   char *fullname;
@@ -80,13 +76,13 @@ scan_filename_with_cleanup (char **cmd, const char *defname)
   else
     {
       /* FIXME: should parse a possibly quoted string.  */
-      char *end;
+      const char *end;
 
-      (*cmd) = skip_spaces (*cmd);
+      (*cmd) = skip_spaces_const (*cmd);
       end = *cmd + strcspn (*cmd, " \t");
       filename = savestring ((*cmd), end - (*cmd));
       make_cleanup (xfree, filename);
-      (*cmd) = skip_spaces (end);
+      (*cmd) = skip_spaces_const (end);
     }
   gdb_assert (filename != NULL);
 
@@ -107,45 +103,40 @@ fopen_with_cleanup (const char *filename, const char *mode)
   return file;
 }
 
-static bfd *
-bfd_openr_with_cleanup (const char *filename, const char *target)
+static gdb_bfd_ref_ptr
+bfd_openr_or_error (const char *filename, const char *target)
 {
-  bfd *ibfd;
-
-  ibfd = gdb_bfd_openr (filename, target);
+  gdb_bfd_ref_ptr ibfd (gdb_bfd_openr (filename, target));
   if (ibfd == NULL)
-    error (_("Failed to open %s: %s."), filename, 
+    error (_("Failed to open %s: %s."), filename,
 	   bfd_errmsg (bfd_get_error ()));
 
-  make_cleanup_bfd_unref (ibfd);
-  if (!bfd_check_format (ibfd, bfd_object))
+  if (!bfd_check_format (ibfd.get (), bfd_object))
     error (_("'%s' is not a recognized file format."), filename);
 
   return ibfd;
 }
 
-static bfd *
-bfd_openw_with_cleanup (const char *filename, const char *target,
-			const char *mode)
+static gdb_bfd_ref_ptr
+bfd_openw_or_error (const char *filename, const char *target, const char *mode)
 {
-  bfd *obfd;
+  gdb_bfd_ref_ptr obfd;
 
   if (*mode == 'w')	/* Write: create new file */
     {
       obfd = gdb_bfd_openw (filename, target);
       if (obfd == NULL)
-	error (_("Failed to open %s: %s."), filename, 
+	error (_("Failed to open %s: %s."), filename,
 	       bfd_errmsg (bfd_get_error ()));
-      make_cleanup_bfd_unref (obfd);
-      if (!bfd_set_format (obfd, bfd_object))
-	error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
+      if (!bfd_set_format (obfd.get (), bfd_object))
+	error (_("bfd_openw_or_error: %s."), bfd_errmsg (bfd_get_error ()));
     }
   else if (*mode == 'a')	/* Append to existing file.  */
     {	/* FIXME -- doesn't work...  */
       error (_("bfd_openw does not work with append."));
     }
   else
-    error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
+    error (_("bfd_openw_or_error: unknown mode %s."), mode);
 
   return obfd;
 }
@@ -154,6 +145,7 @@ static struct cmd_list_element *dump_cmdlist;
 static struct cmd_list_element *append_cmdlist;
 static struct cmd_list_element *srec_cmdlist;
 static struct cmd_list_element *ihex_cmdlist;
+static struct cmd_list_element *verilog_cmdlist;
 static struct cmd_list_element *tekhex_cmdlist;
 static struct cmd_list_element *binary_dump_cmdlist;
 static struct cmd_list_element *binary_append_cmdlist;
@@ -162,14 +154,14 @@ static void
 dump_command (char *cmd, int from_tty)
 {
   printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
-  help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
+  help_list (dump_cmdlist, "dump ", all_commands, gdb_stdout);
 }
 
 static void
 append_command (char *cmd, int from_tty)
 {
   printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
-  help_list (dump_cmdlist, "append ", -1, gdb_stdout);
+  help_list (dump_cmdlist, "append ", all_commands, gdb_stdout);
 }
 
 static void
@@ -190,34 +182,32 @@ dump_bfd_file (const char *filename, const char *mode,
 	       const char *target, CORE_ADDR vaddr, 
 	       const bfd_byte *buf, ULONGEST len)
 {
-  bfd *obfd;
   asection *osection;
 
-  obfd = bfd_openw_with_cleanup (filename, target, mode);
-  osection = bfd_make_section_anyway (obfd, ".newsec");
-  bfd_set_section_size (obfd, osection, len);
-  bfd_set_section_vma (obfd, osection, vaddr);
-  bfd_set_section_alignment (obfd, osection, 0);
-  bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
-					  | SEC_ALLOC
-					  | SEC_LOAD));
+  gdb_bfd_ref_ptr obfd (bfd_openw_or_error (filename, target, mode));
+  osection = bfd_make_section_anyway (obfd.get (), ".newsec");
+  bfd_set_section_size (obfd.get (), osection, len);
+  bfd_set_section_vma (obfd.get (), osection, vaddr);
+  bfd_set_section_alignment (obfd.get (), osection, 0);
+  bfd_set_section_flags (obfd.get (), osection, (SEC_HAS_CONTENTS
+						 | SEC_ALLOC
+						 | SEC_LOAD));
   osection->entsize = 0;
-  if (!bfd_set_section_contents (obfd, osection, buf, 0, len))
-    warning (_("writing dump file '%s' (%s)"), filename, 
+  if (!bfd_set_section_contents (obfd.get (), osection, buf, 0, len))
+    warning (_("writing dump file '%s' (%s)"), filename,
 	     bfd_errmsg (bfd_get_error ()));
 }
 
 static void
-dump_memory_to_file (char *cmd, char *mode, char *file_format)
+dump_memory_to_file (const char *cmd, const char *mode, const char *file_format)
 {
   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
   CORE_ADDR lo;
   CORE_ADDR hi;
   ULONGEST count;
-  char *filename;
-  void *buf;
-  char *lo_exp;
-  char *hi_exp;
+  const char *filename;
+  const char *lo_exp;
+  const char *hi_exp;
 
   /* Open the file.  */
   filename = scan_filename_with_cleanup (&cmd, NULL);
@@ -240,18 +230,17 @@ dump_memory_to_file (char *cmd, char *mode, char *file_format)
 
   /* FIXME: Should use read_memory_partial() and a magic blocking
      value.  */
-  buf = xmalloc (count);
-  make_cleanup (xfree, buf);
-  read_memory (lo, buf, count);
+  std::unique_ptr<gdb_byte[]> buf (new gdb_byte[count]);
+  read_memory (lo, buf.get (), count);
   
   /* Have everything.  Open/write the data.  */
   if (file_format == NULL || strcmp (file_format, "binary") == 0)
     {
-      dump_binary_file (filename, mode, buf, count);
+      dump_binary_file (filename, mode, buf.get (), count);
     }
   else
     {
-      dump_bfd_file (filename, mode, file_format, lo, buf, count);
+      dump_bfd_file (filename, mode, file_format, lo, buf.get (), count);
     }
 
   do_cleanups (old_cleanups);
@@ -264,11 +253,11 @@ dump_memory_command (char *cmd, char *mode)
 }
 
 static void
-dump_value_to_file (char *cmd, char *mode, char *file_format)
+dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
 {
   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
   struct value *val;
-  char *filename;
+  const char *filename;
 
   /* Open the file.  */
   filename = scan_filename_with_cleanup (&cmd, NULL);
@@ -338,6 +327,18 @@ dump_ihex_value (char *args, int from_tty)
   dump_value_to_file (args, FOPEN_WB, "ihex");
 }
 
+static void
+dump_verilog_memory (char *args, int from_tty)
+{
+  dump_memory_to_file (args, FOPEN_WB, "verilog");
+}
+
+static void
+dump_verilog_value (char *args, int from_tty)
+{
+  dump_value_to_file (args, FOPEN_WB, "verilog");
+}
+
 static void
 dump_tekhex_memory (char *args, int from_tty)
 {
@@ -383,7 +384,7 @@ struct dump_context
 static void
 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
 {
-  struct dump_context *d = get_cmd_context (c);
+  struct dump_context *d = (struct dump_context *) get_cmd_context (c);
 
   d->func (args, d->mode);
 }
@@ -398,7 +399,7 @@ add_dump_command (char *name, void (*func) (char *args, char *mode),
 
   c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
   c->completer =  filename_completer;
-  d = XMALLOC (struct dump_context);
+  d = XNEW (struct dump_context);
   d->func = func;
   d->mode = FOPEN_WB;
   set_cmd_context (c, d);
@@ -406,7 +407,7 @@ add_dump_command (char *name, void (*func) (char *args, char *mode),
 
   c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
   c->completer =  filename_completer;
-  d = XMALLOC (struct dump_context);
+  d = XNEW (struct dump_context);
   d->func = func;
   d->mode = FOPEN_AB;
   set_cmd_context (c, d);
@@ -438,7 +439,7 @@ struct callback_data {
 static void
 restore_section_callback (bfd *ibfd, asection *isec, void *args)
 {
-  struct callback_data *data = args;
+  struct callback_data *data = (struct callback_data *) args;
   bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
   bfd_size_type size = bfd_section_size (ibfd, isec);
   bfd_vma sec_end    = sec_start + size;
@@ -473,7 +474,7 @@ restore_section_callback (bfd *ibfd, asection *isec, void *args)
     sec_load_count -= sec_end - data->load_end;
 
   /* Get the data.  */
-  buf = xmalloc (size);
+  buf = (gdb_byte *) xmalloc (size);
   old_chain = make_cleanup (xfree, buf);
   if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
     error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd), 
@@ -505,11 +506,10 @@ restore_section_callback (bfd *ibfd, asection *isec, void *args)
 }
 
 static void
-restore_binary_file (char *filename, struct callback_data *data)
+restore_binary_file (const char *filename, struct callback_data *data)
 {
   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
   FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
-  gdb_byte *buf;
   long len;
 
   /* Get the file size for reading.  */
@@ -544,25 +544,26 @@ restore_binary_file (char *filename, struct callback_data *data)
     perror_with_name (filename);
 
   /* Now allocate a buffer and read the file contents.  */
-  buf = xmalloc (len);
-  make_cleanup (xfree, buf);
-  if (fread (buf, 1, len, file) != len)
+  std::unique_ptr<gdb_byte[]> buf (new gdb_byte[len]);
+  if (fread (buf.get (), 1, len, file) != len)
     perror_with_name (filename);
 
   /* Now write the buffer into target memory.  */
-  len = target_write_memory (data->load_start + data->load_offset, buf, len);
+  len = target_write_memory (data->load_start + data->load_offset,
+			     buf.get (), len);
   if (len != 0)
     warning (_("restore: memory write failed (%s)."), safe_strerror (len));
   do_cleanups (cleanup);
 }
 
 static void
-restore_command (char *args, int from_tty)
+restore_command (char *args_in, int from_tty)
 {
   char *filename;
   struct callback_data data;
   bfd *ibfd;
   int binary_flag = 0;
+  const char *args = args_in;
 
   if (!target_has_execution)
     noprocess ();
@@ -578,16 +579,17 @@ restore_command (char *args, int from_tty)
       char *binary_string = "binary";
 
       /* Look for optional "binary" flag.  */
-      if (strncmp (args, binary_string, strlen (binary_string)) == 0)
+      if (startswith (args, binary_string))
 	{
 	  binary_flag = 1;
 	  args += strlen (binary_string);
-	  args = skip_spaces (args);
+	  args = skip_spaces_const (args);
 	}
       /* Parse offset (optional).  */
       if (args != NULL && *args != '\0')
-      data.load_offset = 
-	parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
+	data.load_offset = binary_flag ?
+	  parse_and_eval_address (scan_expression_with_cleanup (&args, NULL)) :
+	  parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
       if (args != NULL && *args != '\0')
 	{
 	  /* Parse start address (optional).  */
@@ -616,47 +618,54 @@ restore_command (char *args, int from_tty)
   else
     {
       /* Open the file for loading.  */
-      ibfd = bfd_openr_with_cleanup (filename, NULL);
+      gdb_bfd_ref_ptr ibfd (bfd_openr_or_error (filename, NULL));
 
       /* Process the sections.  */
-      bfd_map_over_sections (ibfd, restore_section_callback, &data);
+      bfd_map_over_sections (ibfd.get (), restore_section_callback, &data);
     }
-  return;
 }
 
 static void
 srec_dump_command (char *cmd, int from_tty)
 {
-  printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
-  help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
+  printf_unfiltered (_("\"dump srec\" must be followed by a subcommand.\n"));
+  help_list (srec_cmdlist, "dump srec ", all_commands, gdb_stdout);
 }
 
 static void
 ihex_dump_command (char *cmd, int from_tty)
 {
-  printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
-  help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
+  printf_unfiltered (_("\"dump ihex\" must be followed by a subcommand.\n"));
+  help_list (ihex_cmdlist, "dump ihex ", all_commands, gdb_stdout);
+}
+
+static void
+verilog_dump_command (char *cmd, int from_tty)
+{
+  printf_unfiltered (_("\"dump verilog\" must be followed by a subcommand.\n"));
+  help_list (verilog_cmdlist, "dump verilog ", all_commands, gdb_stdout);
 }
 
 static void
 tekhex_dump_command (char *cmd, int from_tty)
 {
-  printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
-  help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
+  printf_unfiltered (_("\"dump tekhex\" must be followed by a subcommand.\n"));
+  help_list (tekhex_cmdlist, "dump tekhex ", all_commands, gdb_stdout);
 }
 
 static void
 binary_dump_command (char *cmd, int from_tty)
 {
-  printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
-  help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
+  printf_unfiltered (_("\"dump binary\" must be followed by a subcommand.\n"));
+  help_list (binary_dump_cmdlist, "dump binary ", all_commands, gdb_stdout);
 }
 
 static void
 binary_append_command (char *cmd, int from_tty)
 {
-  printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
-  help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
+  printf_unfiltered (_("\"append binary\" must be followed by a subcommand.\n"));
+  help_list (binary_append_cmdlist, "append binary ", all_commands,
+	     gdb_stdout);
 }
 
 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
@@ -699,6 +708,12 @@ the specified FILE in raw target ordered bytes.");
 		  0 /*allow-unknown*/, 
 		  &dump_cmdlist);
 
+  add_prefix_cmd ("verilog", all_commands, verilog_dump_command,
+		  _("Write target code/data to a verilog hex file."),
+		  &verilog_cmdlist, "dump verilog ",
+		  0 /*allow-unknown*/,
+		  &dump_cmdlist);
+
   add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command,
 		  _("Write target code/data to a tekhex file."),
 		  &tekhex_cmdlist, "dump tekhex ", 
@@ -741,6 +756,18 @@ Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 to the specified FILE in intel hex format."),
 	   &ihex_cmdlist);
 
+  add_cmd ("memory", all_commands, dump_verilog_memory, _("\
+Write contents of memory to a verilog hex file.\n\
+Arguments are FILE START STOP.  Writes the contents of memory within\n\
+the range [START .. STOP) to the specified FILE in verilog hex format."),
+	   &verilog_cmdlist);
+
+  add_cmd ("value", all_commands, dump_verilog_value, _("\
+Write the value of an expression to a verilog hex file.\n\
+Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
+to the specified FILE in verilog hex format."),
+	   &verilog_cmdlist);
+
   add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
 Write contents of memory to a tekhex file.\n\
 Arguments are FILE START STOP.  Writes the contents of memory\n\