gdb/cli/cli-dump.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Dump-to-file commands, for GDB, the GNU debugger.

  3.    Copyright (C) 2002-2015 Free Software Foundation, Inc.

  5.    Contributed by Red Hat.

  7.    This file is part of GDB.

  9.    This program is free software; you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation; either version 3 of the License, or
  12.    (at your option) any later version.

  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.

  19.    You should have received a copy of the GNU General Public License
  20.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  22. #include "defs.h"
  23. #include "cli/cli-decode.h"
  24. #include "cli/cli-cmds.h"
  25. #include "value.h"
  26. #include "completer.h"
  27. #include <ctype.h>
  28. #include "target.h"
  29. #include "readline/readline.h"
  30. #include "gdbcore.h"
  31. #include "cli/cli-utils.h"
  32. #include "gdb_bfd.h"
  33. #include "filestuff.h"


  36. static const char *
  37. ‌scan_expression_with_cleanup (const char **cmd, const char *def)
  38. {
  39.   if ((*cmd) == NULL || (**cmd) == '\0')
  40.     {
  41.       char *exp = xstrdup (def);

  43.       make_cleanup (xfree, exp);
  44.       return exp;
  45.     }
  46.   else
  47.     {
  48.       char *exp;
  49.       const char *end;

  51.       end = (*cmd) + strcspn (*cmd, " \t");
  52.       exp = savestring ((*cmd), end - (*cmd));
  53.       make_cleanup (xfree, exp);
  54.       (*cmd) = skip_spaces_const (end);
  55.       return exp;
  56.     }
  57. }


  60. static char *
  61. ‌scan_filename_with_cleanup (const char **cmd, const char *defname)
  62. {
  63.   char *filename;
  64.   char *fullname;

  66.   /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */

  68.   /* File.  */
  69.   if ((*cmd) == NULL)
  70.     {
  71.       if (defname == NULL)
  72.         error (_("Missing filename."));
  73.       filename = xstrdup (defname);
  74.       make_cleanup (xfree, filename);
  75.     }
  76.   else
  77.     {
  78.       /* FIXME: should parse a possibly quoted string.  */
  79.       const char *end;

  81.       (*cmd) = skip_spaces_const (*cmd);
  82.       end = *cmd + strcspn (*cmd, " \t");
  83.       filename = savestring ((*cmd), end - (*cmd));
  84.       make_cleanup (xfree, filename);
  85.       (*cmd) = skip_spaces_const (end);
  86.     }
  87.   gdb_assert (filename != NULL);

  89.   fullname = tilde_expand (filename);
  90.   make_cleanup (xfree, fullname);

  92.   return fullname;
  93. }

  95. static FILE *
  96. ‌fopen_with_cleanup (const char *filename, const char *mode)
  97. {
  98.   FILE *file = gdb_fopen_cloexec (filename, mode);

  100.   if (file == NULL)
  101.     perror_with_name (filename);
  102.   make_cleanup_fclose (file);
  103.   return file;
  104. }

  106. static bfd *
  107. ‌bfd_openr_with_cleanup (const char *filename, const char *target)
  108. {
  109.   bfd *ibfd;

  111.   ibfd = gdb_bfd_openr (filename, target);
  112.   if (ibfd == NULL)
  113.     error (_("Failed to open %s: %s."), filename,
  114.            bfd_errmsg (bfd_get_error ()));

  116.   make_cleanup_bfd_unref (ibfd);
  117.   if (!bfd_check_format (ibfd, bfd_object))
  118.     error (_("'%s' is not a recognized file format."), filename);

  120.   return ibfd;
  121. }

  123. static bfd *
  124. ‌bfd_openw_with_cleanup (const char *filename, const char *target,
  125.                         const char *mode)
  126. {
  127.   bfd *obfd;

  129.   if (*mode == 'w')        /* Write: create new file */
  130.     {
  131.       obfd = gdb_bfd_openw (filename, target);
  132.       if (obfd == NULL)
  133.         error (_("Failed to open %s: %s."), filename,
  134.                bfd_errmsg (bfd_get_error ()));
  135.       make_cleanup_bfd_unref (obfd);
  136.       if (!bfd_set_format (obfd, bfd_object))
  137.         error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
  138.     }
  139.   else if (*mode == 'a')        /* Append to existing file.  */
  140.     {        /* FIXME -- doesn't work...  */
  141.       error (_("bfd_openw does not work with append."));
  142.     }
  143.   else
  144.     error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);

  146.   return obfd;
  147. }

  149. ‌static struct cmd_list_element *dump_cmdlist;
  150. ‌static struct cmd_list_element *append_cmdlist;
  151. ‌static struct cmd_list_element *srec_cmdlist;
  152. ‌static struct cmd_list_element *ihex_cmdlist;
  153. ‌static struct cmd_list_element *tekhex_cmdlist;
  154. ‌static struct cmd_list_element *binary_dump_cmdlist;
  155. ‌static struct cmd_list_element *binary_append_cmdlist;

  157. static void
  158. ‌dump_command (char *cmd, int from_tty)
  159. {
  160.   printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
  161.   help_list (dump_cmdlist, "dump ", all_commands, gdb_stdout);
  162. }

  164. static void
  165. ‌append_command (char *cmd, int from_tty)
  166. {
  167.   printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
  168.   help_list (dump_cmdlist, "append ", all_commands, gdb_stdout);
  169. }

  171. static void
  172. ‌dump_binary_file (const char *filename, const char *mode,
  173.                   const bfd_byte *buf, ULONGEST len)
  174. {
  175.   FILE *file;
  176.   int status;

  178.   file = fopen_with_cleanup (filename, mode);
  179.   status = fwrite (buf, len, 1, file);
  180.   if (status != 1)
  181.     perror_with_name (filename);
  182. }

  184. static void
  185. ‌dump_bfd_file (const char *filename, const char *mode,
  186.                const char *target, CORE_ADDR vaddr,
  187.                const bfd_byte *buf, ULONGEST len)
  188. {
  189.   bfd *obfd;
  190.   asection *osection;

  192.   obfd = bfd_openw_with_cleanup (filename, target, mode);
  193.   osection = bfd_make_section_anyway (obfd, ".newsec");
  194.   bfd_set_section_size (obfd, osection, len);
  195.   bfd_set_section_vma (obfd, osection, vaddr);
  196.   bfd_set_section_alignment (obfd, osection, 0);
  197.   bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
  198.                                           | SEC_ALLOC
  199.                                           | SEC_LOAD));
  200.   osection->entsize = 0;
  201.   if (!bfd_set_section_contents (obfd, osection, buf, 0, len))
  202.     warning (_("writing dump file '%s' (%s)"), filename,
  203.              bfd_errmsg (bfd_get_error ()));
  204. }

  206. static void
  207. ‌dump_memory_to_file (const char *cmd, const char *mode, const char *file_format)
  208. {
  209.   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
  210.   CORE_ADDR lo;
  211.   CORE_ADDR hi;
  212.   ULONGEST count;
  213.   const char *filename;
  214.   void *buf;
  215.   const char *lo_exp;
  216.   const char *hi_exp;

  218.   /* Open the file.  */
  219.   filename = scan_filename_with_cleanup (&cmd, NULL);

  221.   /* Find the low address.  */
  222.   if (cmd == NULL || *cmd == '\0')
  223.     error (_("Missing start address."));
  224.   lo_exp = scan_expression_with_cleanup (&cmd, NULL);

  226.   /* Find the second address - rest of line.  */
  227.   if (cmd == NULL || *cmd == '\0')
  228.     error (_("Missing stop address."));
  229.   hi_exp = cmd;

  231.   lo = parse_and_eval_address (lo_exp);
  232.   hi = parse_and_eval_address (hi_exp);
  233.   if (hi <= lo)
  234.     error (_("Invalid memory address range (start >= end)."));
  235.   count = hi - lo;

  237.   /* FIXME: Should use read_memory_partial() and a magic blocking
  238.      value.  */
  239.   buf = xmalloc (count);
  240.   make_cleanup (xfree, buf);
  241.   read_memory (lo, buf, count);

  243.   /* Have everything.  Open/write the data.  */
  244.   if (file_format == NULL || strcmp (file_format, "binary") == 0)
  245.     {
  246.       dump_binary_file (filename, mode, buf, count);
  247.     }
  248.   else
  249.     {
  250.       dump_bfd_file (filename, mode, file_format, lo, buf, count);
  251.     }

  253.   do_cleanups (old_cleanups);
  254. }

  256. static void
  257. ‌dump_memory_command (char *cmd, char *mode)
  258. {
  259.   dump_memory_to_file (cmd, mode, "binary");
  260. }

  262. static void
  263. ‌dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
  264. {
  265.   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
  266.   struct value *val;
  267.   const char *filename;

  269.   /* Open the file.  */
  270.   filename = scan_filename_with_cleanup (&cmd, NULL);

  272.   /* Find the value.  */
  273.   if (cmd == NULL || *cmd == '\0')
  274.     error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
  275.   val = parse_and_eval (cmd);
  276.   if (val == NULL)
  277.     error (_("Invalid expression."));

  279.   /* Have everything.  Open/write the data.  */
  280.   if (file_format == NULL || strcmp (file_format, "binary") == 0)
  281.     {
  282.       dump_binary_file (filename, mode, value_contents (val),
  283.                         TYPE_LENGTH (value_type (val)));
  284.     }
  285.   else
  286.     {
  287.       CORE_ADDR vaddr;

  289.       if (VALUE_LVAL (val))
  290.         {
  291.           vaddr = value_address (val);
  292.         }
  293.       else
  294.         {
  295.           vaddr = 0;
  296.           warning (_("value is not an lval: address assumed to be zero"));
  297.         }

  299.       dump_bfd_file (filename, mode, file_format, vaddr,
  300.                      value_contents (val),
  301.                      TYPE_LENGTH (value_type (val)));
  302.     }

  304.   do_cleanups (old_cleanups);
  305. }

  307. static void
  308. ‌dump_value_command (char *cmd, char *mode)
  309. {
  310.   dump_value_to_file (cmd, mode, "binary");
  311. }

  313. static void
  314. ‌dump_srec_memory (char *args, int from_tty)
  315. {
  316.   dump_memory_to_file (args, FOPEN_WB, "srec");
  317. }

  319. static void
  320. ‌dump_srec_value (char *args, int from_tty)
  321. {
  322.   dump_value_to_file (args, FOPEN_WB, "srec");
  323. }

  325. static void
  326. ‌dump_ihex_memory (char *args, int from_tty)
  327. {
  328.   dump_memory_to_file (args, FOPEN_WB, "ihex");
  329. }

  331. static void
  332. ‌dump_ihex_value (char *args, int from_tty)
  333. {
  334.   dump_value_to_file (args, FOPEN_WB, "ihex");
  335. }

  337. static void
  338. ‌dump_tekhex_memory (char *args, int from_tty)
  339. {
  340.   dump_memory_to_file (args, FOPEN_WB, "tekhex");
  341. }

  343. static void
  344. ‌dump_tekhex_value (char *args, int from_tty)
  345. {
  346.   dump_value_to_file (args, FOPEN_WB, "tekhex");
  347. }

  349. static void
  350. ‌dump_binary_memory (char *args, int from_tty)
  351. {
  352.   dump_memory_to_file (args, FOPEN_WB, "binary");
  353. }

  355. static void
  356. ‌dump_binary_value (char *args, int from_tty)
  357. {
  358.   dump_value_to_file (args, FOPEN_WB, "binary");
  359. }

  361. static void
  362. ‌append_binary_memory (char *args, int from_tty)
  363. {
  364.   dump_memory_to_file (args, FOPEN_AB, "binary");
  365. }

  367. static void
  368. ‌append_binary_value (char *args, int from_tty)
  369. {
  370.   dump_value_to_file (args, FOPEN_AB, "binary");
  371. }

  373. ‌struct dump_context
  374. {
  375.   void (*func) (char *cmd, char *mode);
  376.   char *mode;
  377. };

  379. static void
  380. ‌call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
  381. {
  382.   struct dump_context *d = get_cmd_context (c);

  384.   d->func (args, d->mode);
  385. }

  387. static void
  388. ‌add_dump_command (char *name, void (*func) (char *args, char *mode),
  389.                   char *descr)

  391. {
  392.   struct cmd_list_element *c;
  393.   struct dump_context *d;

  395.   c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
  396.   c->completer =  filename_completer;
  397.   d = XNEW (struct dump_context);
  398.   d->func = func;
  399.   d->mode = FOPEN_WB;
  400.   set_cmd_context (c, d);
  401.   c->func = call_dump_func;

  403.   c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
  404.   c->completer =  filename_completer;
  405.   d = XNEW (struct dump_context);
  406.   d->func = func;
  407.   d->mode = FOPEN_AB;
  408.   set_cmd_context (c, d);
  409.   c->func = call_dump_func;

  411.   /* Replace "Dump " at start of docstring with "Append " (borrowed
  412.      from [deleted] deprecated_add_show_from_set).  */
  413.   if (   c->doc[0] == 'W'
  414.       && c->doc[1] == 'r'
  415.       && c->doc[2] == 'i'
  416.       && c->doc[3] == 't'
  417.       && c->doc[4] == 'e'
  418.       && c->doc[5] == ' ')
  419.     c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
  420. }

  422. /* Opaque data for restore_section_callback.  */
  423. ‌struct callback_data {
  424.   CORE_ADDR load_offset;
  425.   CORE_ADDR load_start;
  426.   CORE_ADDR load_end;
  427. };

  429. /* Function: restore_section_callback.

  431.    Callback function for bfd_map_over_sections.
  432.    Selectively loads the sections into memory.  */

  434. static void
  435. ‌restore_section_callback (bfd *ibfd, asection *isec, void *args)
  436. {
  437.   struct callback_data *data = args;
  438.   bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
  439.   bfd_size_type size = bfd_section_size (ibfd, isec);
  440.   bfd_vma sec_end    = sec_start + size;
  441.   bfd_size_type sec_offset = 0;
  442.   bfd_size_type sec_load_count = size;
  443.   struct cleanup *old_chain;
  444.   gdb_byte *buf;
  445.   int ret;

  447.   /* Ignore non-loadable sections, eg. from elf files.  */
  448.   if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
  449.     return;

  451.   /* Does the section overlap with the desired restore range? */
  452.   if (sec_end <= data->load_start
  453.       || (data->load_end > 0 && sec_start >= data->load_end))
  454.     {
  455.       /* No, no useable data in this section.  */
  456.       printf_filtered (_("skipping section %s...\n"),
  457.                        bfd_section_name (ibfd, isec));
  458.       return;
  459.     }

  461.   /* Compare section address range with user-requested
  462.      address range (if any).  Compute where the actual
  463.      transfer should start and end.  */
  464.   if (sec_start < data->load_start)
  465.     sec_offset = data->load_start - sec_start;
  466.   /* Size of a partial transfer.  */
  467.   sec_load_count -= sec_offset;
  468.   if (data->load_end > 0 && sec_end > data->load_end)
  469.     sec_load_count -= sec_end - data->load_end;

  471.   /* Get the data.  */
  472.   buf = xmalloc (size);
  473.   old_chain = make_cleanup (xfree, buf);
  474.   if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
  475.     error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
  476.            bfd_errmsg (bfd_get_error ()));

  478.   printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
  479.                    bfd_section_name (ibfd, isec),
  480.                    (unsigned long) sec_start,
  481.                    (unsigned long) sec_end);

  483.   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
  484.     printf_filtered (" into memory (%s to %s)\n",
  485.                      paddress (target_gdbarch (),
  486.                                (unsigned long) sec_start
  487.                                + sec_offset + data->load_offset),
  488.                      paddress (target_gdbarch (),
  489.                                (unsigned long) sec_start + sec_offset
  490.                                 + data->load_offset + sec_load_count));
  491.   else
  492.     puts_filtered ("\n");

  494.   /* Write the data.  */
  495.   ret = target_write_memory (sec_start + sec_offset + data->load_offset,
  496.                              buf + sec_offset, sec_load_count);
  497.   if (ret != 0)
  498.     warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
  499.   do_cleanups (old_chain);
  500.   return;
  501. }

  503. static void
  504. ‌restore_binary_file (const char *filename, struct callback_data *data)
  505. {
  506.   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
  507.   FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
  508.   gdb_byte *buf;
  509.   long len;

  511.   /* Get the file size for reading.  */
  512.   if (fseek (file, 0, SEEK_END) == 0)
  513.     {
  514.       len = ftell (file);
  515.       if (len < 0)
  516.         perror_with_name (filename);
  517.     }
  518.   else
  519.     perror_with_name (filename);

  521.   if (len <= data->load_start)
  522.     error (_("Start address is greater than length of binary file %s."),
  523.            filename);

  525.   /* Chop off "len" if it exceeds the requested load_end addr.  */
  526.   if (data->load_end != 0 && data->load_end < len)
  527.     len = data->load_end;
  528.   /* Chop off "len" if the requested load_start addr skips some bytes.  */
  529.   if (data->load_start > 0)
  530.     len -= data->load_start;

  532.   printf_filtered
  533.     ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
  534.      filename,
  535.      (unsigned long) (data->load_start + data->load_offset),
  536.      (unsigned long) (data->load_start + data->load_offset + len));

  538.   /* Now set the file pos to the requested load start pos.  */
  539.   if (fseek (file, data->load_start, SEEK_SET) != 0)
  540.     perror_with_name (filename);

  542.   /* Now allocate a buffer and read the file contents.  */
  543.   buf = xmalloc (len);
  544.   make_cleanup (xfree, buf);
  545.   if (fread (buf, 1, len, file) != len)
  546.     perror_with_name (filename);

  548.   /* Now write the buffer into target memory.  */
  549.   len = target_write_memory (data->load_start + data->load_offset, buf, len);
  550.   if (len != 0)
  551.     warning (_("restore: memory write failed (%s)."), safe_strerror (len));
  552.   do_cleanups (cleanup);
  553. }

  555. static void
  556. ‌restore_command (char *args_in, int from_tty)
  557. {
  558.   char *filename;
  559.   struct callback_data data;
  560.   bfd *ibfd;
  561.   int binary_flag = 0;
  562.   const char *args = args_in;

  564.   if (!target_has_execution)
  565.     noprocess ();

  567.   data.load_offset = 0;
  568.   data.load_start  = 0;
  569.   data.load_end    = 0;

  571.   /* Parse the input arguments.  First is filename (required).  */
  572.   filename = scan_filename_with_cleanup (&args, NULL);
  573.   if (args != NULL && *args != '\0')
  574.     {
  575.       char *binary_string = "binary";

  577.       /* Look for optional "binary" flag.  */
  578.       if (strncmp (args, binary_string, strlen (binary_string)) == 0)
  579.         {
  580.           binary_flag = 1;
  581.           args += strlen (binary_string);
  582.           args = skip_spaces_const (args);
  583.         }
  584.       /* Parse offset (optional).  */
  585.       if (args != NULL && *args != '\0')
  586.       data.load_offset =
  587.         parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
  588.       if (args != NULL && *args != '\0')
  589.         {
  590.           /* Parse start address (optional).  */
  591.           data.load_start =
  592.             parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
  593.           if (args != NULL && *args != '\0')
  594.             {
  595.               /* Parse end address (optional).  */
  596.               data.load_end = parse_and_eval_long (args);
  597.               if (data.load_end <= data.load_start)
  598.                 error (_("Start must be less than end."));
  599.             }
  600.         }
  601.     }

  603.   if (info_verbose)
  604.     printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
  605.                      filename, (unsigned long) data.load_offset,
  606.                      (unsigned long) data.load_start,
  607.                      (unsigned long) data.load_end);

  609.   if (binary_flag)
  610.     {
  611.       restore_binary_file (filename, &data);
  612.     }
  613.   else
  614.     {
  615.       /* Open the file for loading.  */
  616.       ibfd = bfd_openr_with_cleanup (filename, NULL);

  618.       /* Process the sections.  */
  619.       bfd_map_over_sections (ibfd, restore_section_callback, &data);
  620.     }
  621.   return;
  622. }

  624. static void
  625. ‌srec_dump_command (char *cmd, int from_tty)
  626. {
  627.   printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
  628.   help_list (srec_cmdlist, "dump srec ", all_commands, gdb_stdout);
  629. }

  631. static void
  632. ‌ihex_dump_command (char *cmd, int from_tty)
  633. {
  634.   printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
  635.   help_list (ihex_cmdlist, "dump ihex ", all_commands, gdb_stdout);
  636. }

  638. static void
  639. ‌tekhex_dump_command (char *cmd, int from_tty)
  640. {
  641.   printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
  642.   help_list (tekhex_cmdlist, "dump tekhex ", all_commands, gdb_stdout);
  643. }

  645. static void
  646. ‌binary_dump_command (char *cmd, int from_tty)
  647. {
  648.   printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
  649.   help_list (binary_dump_cmdlist, "dump binary ", all_commands, gdb_stdout);
  650. }

  652. static void
  653. ‌binary_append_command (char *cmd, int from_tty)
  654. {
  655.   printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
  656.   help_list (binary_append_cmdlist, "append binary ", all_commands,
  657.              gdb_stdout);
  658. }

  660. extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */

  662. void
  663. ‌_initialize_cli_dump (void)
  664. {
  665.   struct cmd_list_element *c;

  667.   add_prefix_cmd ("dump", class_vars, dump_command,
  668.                   _("Dump target code/data to a local file."),
  669.                   &dump_cmdlist, "dump ",
  670.                   0/*allow-unknown*/,
  671.                   &cmdlist);
  672.   add_prefix_cmd ("append", class_vars, append_command,
  673.                   _("Append target code/data to a local file."),
  674.                   &append_cmdlist, "append ",
  675.                   0/*allow-unknown*/,
  676.                   &cmdlist);

  678.   add_dump_command ("memory", dump_memory_command, "\
  679. Write contents of memory to a raw binary file.\n\
  680. Arguments are FILE START STOP.  Writes the contents of memory within the\n\
  681. range [START .. STOP) to the specified FILE in raw target ordered bytes.");

  683.   add_dump_command ("value", dump_value_command, "\
  684. Write the value of an expression to a raw binary file.\n\
  685. Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION to\n\
  686. the specified FILE in raw target ordered bytes.");

  688.   add_prefix_cmd ("srec", all_commands, srec_dump_command,
  689.                   _("Write target code/data to an srec file."),
  690.                   &srec_cmdlist, "dump srec ",
  691.                   0 /*allow-unknown*/,
  692.                   &dump_cmdlist);

  694.   add_prefix_cmd ("ihex", all_commands, ihex_dump_command,
  695.                   _("Write target code/data to an intel hex file."),
  696.                   &ihex_cmdlist, "dump ihex ",
  697.                   0 /*allow-unknown*/,
  698.                   &dump_cmdlist);

  700.   add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command,
  701.                   _("Write target code/data to a tekhex file."),
  702.                   &tekhex_cmdlist, "dump tekhex ",
  703.                   0 /*allow-unknown*/,
  704.                   &dump_cmdlist);

  706.   add_prefix_cmd ("binary", all_commands, binary_dump_command,
  707.                   _("Write target code/data to a raw binary file."),
  708.                   &binary_dump_cmdlist, "dump binary ",
  709.                   0 /*allow-unknown*/,
  710.                   &dump_cmdlist);

  712.   add_prefix_cmd ("binary", all_commands, binary_append_command,
  713.                   _("Append target code/data to a raw binary file."),
  714.                   &binary_append_cmdlist, "append binary ",
  715.                   0 /*allow-unknown*/,
  716.                   &append_cmdlist);

  718.   add_cmd ("memory", all_commands, dump_srec_memory, _("\
  719. Write contents of memory to an srec file.\n\
  720. Arguments are FILE START STOP.  Writes the contents of memory\n\
  721. within the range [START .. STOP) to the specified FILE in srec format."),
  722.            &srec_cmdlist);

  724.   add_cmd ("value", all_commands, dump_srec_value, _("\
  725. Write the value of an expression to an srec file.\n\
  726. Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
  727. to the specified FILE in srec format."),
  728.            &srec_cmdlist);

  730.   add_cmd ("memory", all_commands, dump_ihex_memory, _("\
  731. Write contents of memory to an ihex file.\n\
  732. Arguments are FILE START STOP.  Writes the contents of memory within\n\
  733. the range [START .. STOP) to the specified FILE in intel hex format."),
  734.            &ihex_cmdlist);

  736.   add_cmd ("value", all_commands, dump_ihex_value, _("\
  737. Write the value of an expression to an ihex file.\n\
  738. Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
  739. to the specified FILE in intel hex format."),
  740.            &ihex_cmdlist);

  742.   add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
  743. Write contents of memory to a tekhex file.\n\
  744. Arguments are FILE START STOP.  Writes the contents of memory\n\
  745. within the range [START .. STOP) to the specified FILE in tekhex format."),
  746.            &tekhex_cmdlist);

  748.   add_cmd ("value", all_commands, dump_tekhex_value, _("\
  749. Write the value of an expression to a tekhex file.\n\
  750. Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
  751. to the specified FILE in tekhex format."),
  752.            &tekhex_cmdlist);

  754.   add_cmd ("memory", all_commands, dump_binary_memory, _("\
  755. Write contents of memory to a raw binary file.\n\
  756. Arguments are FILE START STOP.  Writes the contents of memory\n\
  757. within the range [START .. STOP) to the specified FILE in binary format."),
  758.            &binary_dump_cmdlist);

  760.   add_cmd ("value", all_commands, dump_binary_value, _("\
  761. Write the value of an expression to a raw binary file.\n\
  762. Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
  763. to the specified FILE in raw target ordered bytes."),
  764.            &binary_dump_cmdlist);

  766.   add_cmd ("memory", all_commands, append_binary_memory, _("\
  767. Append contents of memory to a raw binary file.\n\
  768. Arguments are FILE START STOP.  Writes the contents of memory within the\n\
  769. range [START .. STOP) to the specified FILE in raw target ordered bytes."),
  770.            &binary_append_cmdlist);

  772.   add_cmd ("value", all_commands, append_binary_value, _("\
  773. Append the value of an expression to a raw binary file.\n\
  774. Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
  775. to the specified FILE in raw target ordered bytes."),
  776.            &binary_append_cmdlist);

  778.   c = add_com ("restore", class_vars, restore_command, _("\
  779. Restore the contents of FILE to target memory.\n\
  780. Arguments are FILE OFFSET START END where all except FILE are optional.\n\
  781. OFFSET will be added to the base address of the file (default zero).\n\
  782. If START and END are given, only the file contents within that range\n\
  783. (file relative) will be restored to target memory."));
  784.   c->completer = filename_completer;
  785.   /* FIXME: completers for other commands.  */
  786. }