Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / cli / cli-dump.c
1 /* Dump-to-file commands, for GDB, the GNU debugger.
2
3    Copyright (C) 2002-2013 Free Software Foundation, Inc.
4
5    Contributed by Red Hat.
6
7    This file is part of GDB.
8
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.
13
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.
18
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/>.  */
21
22 #include "defs.h"
23 #include "gdb_string.h"
24 #include "cli/cli-decode.h"
25 #include "cli/cli-cmds.h"
26 #include "value.h"
27 #include "completer.h"
28 #include "cli/cli-dump.h"
29 #include "gdb_assert.h"
30 #include <ctype.h>
31 #include "target.h"
32 #include "readline/readline.h"
33 #include "gdbcore.h"
34 #include "cli/cli-utils.h"
35 #include "gdb_bfd.h"
36
37 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
38
39
40 char *
41 scan_expression_with_cleanup (char **cmd, const char *def)
42 {
43   if ((*cmd) == NULL || (**cmd) == '\0')
44     {
45       char *exp = xstrdup (def);
46
47       make_cleanup (xfree, exp);
48       return exp;
49     }
50   else
51     {
52       char *exp;
53       char *end;
54
55       end = (*cmd) + strcspn (*cmd, " \t");
56       exp = savestring ((*cmd), end - (*cmd));
57       make_cleanup (xfree, exp);
58       (*cmd) = skip_spaces (end);
59       return exp;
60     }
61 }
62
63
64 char *
65 scan_filename_with_cleanup (char **cmd, const char *defname)
66 {
67   char *filename;
68   char *fullname;
69
70   /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */
71
72   /* File.  */
73   if ((*cmd) == NULL)
74     {
75       if (defname == NULL)
76         error (_("Missing filename."));
77       filename = xstrdup (defname);
78       make_cleanup (xfree, filename);
79     }
80   else
81     {
82       /* FIXME: should parse a possibly quoted string.  */
83       char *end;
84
85       (*cmd) = skip_spaces (*cmd);
86       end = *cmd + strcspn (*cmd, " \t");
87       filename = savestring ((*cmd), end - (*cmd));
88       make_cleanup (xfree, filename);
89       (*cmd) = skip_spaces (end);
90     }
91   gdb_assert (filename != NULL);
92
93   fullname = tilde_expand (filename);
94   make_cleanup (xfree, fullname);
95   
96   return fullname;
97 }
98
99 FILE *
100 fopen_with_cleanup (const char *filename, const char *mode)
101 {
102   FILE *file = fopen (filename, mode);
103
104   if (file == NULL)
105     perror_with_name (filename);
106   make_cleanup_fclose (file);
107   return file;
108 }
109
110 static bfd *
111 bfd_openr_with_cleanup (const char *filename, const char *target)
112 {
113   bfd *ibfd;
114
115   ibfd = gdb_bfd_openr (filename, target);
116   if (ibfd == NULL)
117     error (_("Failed to open %s: %s."), filename, 
118            bfd_errmsg (bfd_get_error ()));
119
120   make_cleanup_bfd_unref (ibfd);
121   if (!bfd_check_format (ibfd, bfd_object))
122     error (_("'%s' is not a recognized file format."), filename);
123
124   return ibfd;
125 }
126
127 static bfd *
128 bfd_openw_with_cleanup (const char *filename, const char *target,
129                         const char *mode)
130 {
131   bfd *obfd;
132
133   if (*mode == 'w')     /* Write: create new file */
134     {
135       obfd = gdb_bfd_openw (filename, target);
136       if (obfd == NULL)
137         error (_("Failed to open %s: %s."), filename, 
138                bfd_errmsg (bfd_get_error ()));
139       make_cleanup_bfd_unref (obfd);
140       if (!bfd_set_format (obfd, bfd_object))
141         error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
142     }
143   else if (*mode == 'a')        /* Append to existing file.  */
144     {   /* FIXME -- doesn't work...  */
145       error (_("bfd_openw does not work with append."));
146     }
147   else
148     error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
149
150   return obfd;
151 }
152
153 static struct cmd_list_element *dump_cmdlist;
154 static struct cmd_list_element *append_cmdlist;
155 static struct cmd_list_element *srec_cmdlist;
156 static struct cmd_list_element *ihex_cmdlist;
157 static struct cmd_list_element *tekhex_cmdlist;
158 static struct cmd_list_element *binary_dump_cmdlist;
159 static struct cmd_list_element *binary_append_cmdlist;
160
161 static void
162 dump_command (char *cmd, int from_tty)
163 {
164   printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
165   help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
166 }
167
168 static void
169 append_command (char *cmd, int from_tty)
170 {
171   printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
172   help_list (dump_cmdlist, "append ", -1, gdb_stdout);
173 }
174
175 static void
176 dump_binary_file (const char *filename, const char *mode, 
177                   const bfd_byte *buf, ULONGEST len)
178 {
179   FILE *file;
180   int status;
181
182   file = fopen_with_cleanup (filename, mode);
183   status = fwrite (buf, len, 1, file);
184   if (status != 1)
185     perror_with_name (filename);
186 }
187
188 static void
189 dump_bfd_file (const char *filename, const char *mode, 
190                const char *target, CORE_ADDR vaddr, 
191                const bfd_byte *buf, ULONGEST len)
192 {
193   bfd *obfd;
194   asection *osection;
195
196   obfd = bfd_openw_with_cleanup (filename, target, mode);
197   osection = bfd_make_section_anyway (obfd, ".newsec");
198   bfd_set_section_size (obfd, osection, len);
199   bfd_set_section_vma (obfd, osection, vaddr);
200   bfd_set_section_alignment (obfd, osection, 0);
201   bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
202                                           | SEC_ALLOC
203                                           | SEC_LOAD));
204   osection->entsize = 0;
205   if (!bfd_set_section_contents (obfd, osection, buf, 0, len))
206     warning (_("writing dump file '%s' (%s)"), filename, 
207              bfd_errmsg (bfd_get_error ()));
208 }
209
210 static void
211 dump_memory_to_file (char *cmd, char *mode, char *file_format)
212 {
213   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
214   CORE_ADDR lo;
215   CORE_ADDR hi;
216   ULONGEST count;
217   char *filename;
218   void *buf;
219   char *lo_exp;
220   char *hi_exp;
221
222   /* Open the file.  */
223   filename = scan_filename_with_cleanup (&cmd, NULL);
224
225   /* Find the low address.  */
226   if (cmd == NULL || *cmd == '\0')
227     error (_("Missing start address."));
228   lo_exp = scan_expression_with_cleanup (&cmd, NULL);
229
230   /* Find the second address - rest of line.  */
231   if (cmd == NULL || *cmd == '\0')
232     error (_("Missing stop address."));
233   hi_exp = cmd;
234
235   lo = parse_and_eval_address (lo_exp);
236   hi = parse_and_eval_address (hi_exp);
237   if (hi <= lo)
238     error (_("Invalid memory address range (start >= end)."));
239   count = hi - lo;
240
241   /* FIXME: Should use read_memory_partial() and a magic blocking
242      value.  */
243   buf = xmalloc (count);
244   make_cleanup (xfree, buf);
245   read_memory (lo, buf, count);
246   
247   /* Have everything.  Open/write the data.  */
248   if (file_format == NULL || strcmp (file_format, "binary") == 0)
249     {
250       dump_binary_file (filename, mode, buf, count);
251     }
252   else
253     {
254       dump_bfd_file (filename, mode, file_format, lo, buf, count);
255     }
256
257   do_cleanups (old_cleanups);
258 }
259
260 static void
261 dump_memory_command (char *cmd, char *mode)
262 {
263   dump_memory_to_file (cmd, mode, "binary");
264 }
265
266 static void
267 dump_value_to_file (char *cmd, char *mode, char *file_format)
268 {
269   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
270   struct value *val;
271   char *filename;
272
273   /* Open the file.  */
274   filename = scan_filename_with_cleanup (&cmd, NULL);
275
276   /* Find the value.  */
277   if (cmd == NULL || *cmd == '\0')
278     error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
279   val = parse_and_eval (cmd);
280   if (val == NULL)
281     error (_("Invalid expression."));
282
283   /* Have everything.  Open/write the data.  */
284   if (file_format == NULL || strcmp (file_format, "binary") == 0)
285     {
286       dump_binary_file (filename, mode, value_contents (val), 
287                         TYPE_LENGTH (value_type (val)));
288     }
289   else
290     {
291       CORE_ADDR vaddr;
292
293       if (VALUE_LVAL (val))
294         {
295           vaddr = value_address (val);
296         }
297       else
298         {
299           vaddr = 0;
300           warning (_("value is not an lval: address assumed to be zero"));
301         }
302
303       dump_bfd_file (filename, mode, file_format, vaddr, 
304                      value_contents (val), 
305                      TYPE_LENGTH (value_type (val)));
306     }
307
308   do_cleanups (old_cleanups);
309 }
310
311 static void
312 dump_value_command (char *cmd, char *mode)
313 {
314   dump_value_to_file (cmd, mode, "binary");
315 }
316
317 static void
318 dump_srec_memory (char *args, int from_tty)
319 {
320   dump_memory_to_file (args, FOPEN_WB, "srec");
321 }
322
323 static void
324 dump_srec_value (char *args, int from_tty)
325 {
326   dump_value_to_file (args, FOPEN_WB, "srec");
327 }
328
329 static void
330 dump_ihex_memory (char *args, int from_tty)
331 {
332   dump_memory_to_file (args, FOPEN_WB, "ihex");
333 }
334
335 static void
336 dump_ihex_value (char *args, int from_tty)
337 {
338   dump_value_to_file (args, FOPEN_WB, "ihex");
339 }
340
341 static void
342 dump_tekhex_memory (char *args, int from_tty)
343 {
344   dump_memory_to_file (args, FOPEN_WB, "tekhex");
345 }
346
347 static void
348 dump_tekhex_value (char *args, int from_tty)
349 {
350   dump_value_to_file (args, FOPEN_WB, "tekhex");
351 }
352
353 static void
354 dump_binary_memory (char *args, int from_tty)
355 {
356   dump_memory_to_file (args, FOPEN_WB, "binary");
357 }
358
359 static void
360 dump_binary_value (char *args, int from_tty)
361 {
362   dump_value_to_file (args, FOPEN_WB, "binary");
363 }
364
365 static void
366 append_binary_memory (char *args, int from_tty)
367 {
368   dump_memory_to_file (args, FOPEN_AB, "binary");
369 }
370
371 static void
372 append_binary_value (char *args, int from_tty)
373 {
374   dump_value_to_file (args, FOPEN_AB, "binary");
375 }
376
377 struct dump_context
378 {
379   void (*func) (char *cmd, char *mode);
380   char *mode;
381 };
382
383 static void
384 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
385 {
386   struct dump_context *d = get_cmd_context (c);
387
388   d->func (args, d->mode);
389 }
390
391 void
392 add_dump_command (char *name, void (*func) (char *args, char *mode),
393                   char *descr)
394
395 {
396   struct cmd_list_element *c;
397   struct dump_context *d;
398
399   c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
400   c->completer =  filename_completer;
401   d = XMALLOC (struct dump_context);
402   d->func = func;
403   d->mode = FOPEN_WB;
404   set_cmd_context (c, d);
405   c->func = call_dump_func;
406
407   c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
408   c->completer =  filename_completer;
409   d = XMALLOC (struct dump_context);
410   d->func = func;
411   d->mode = FOPEN_AB;
412   set_cmd_context (c, d);
413   c->func = call_dump_func;
414
415   /* Replace "Dump " at start of docstring with "Append " (borrowed
416      from [deleted] deprecated_add_show_from_set).  */
417   if (   c->doc[0] == 'W' 
418       && c->doc[1] == 'r' 
419       && c->doc[2] == 'i'
420       && c->doc[3] == 't' 
421       && c->doc[4] == 'e'
422       && c->doc[5] == ' ')
423     c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
424 }
425
426 /* Opaque data for restore_section_callback.  */
427 struct callback_data {
428   CORE_ADDR load_offset;
429   CORE_ADDR load_start;
430   CORE_ADDR load_end;
431 };
432
433 /* Function: restore_section_callback.
434
435    Callback function for bfd_map_over_sections.
436    Selectively loads the sections into memory.  */
437
438 static void
439 restore_section_callback (bfd *ibfd, asection *isec, void *args)
440 {
441   struct callback_data *data = args;
442   bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
443   bfd_size_type size = bfd_section_size (ibfd, isec);
444   bfd_vma sec_end    = sec_start + size;
445   bfd_size_type sec_offset = 0;
446   bfd_size_type sec_load_count = size;
447   struct cleanup *old_chain;
448   gdb_byte *buf;
449   int ret;
450
451   /* Ignore non-loadable sections, eg. from elf files.  */
452   if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
453     return;
454
455   /* Does the section overlap with the desired restore range? */
456   if (sec_end <= data->load_start 
457       || (data->load_end > 0 && sec_start >= data->load_end))
458     {
459       /* No, no useable data in this section.  */
460       printf_filtered (_("skipping section %s...\n"), 
461                        bfd_section_name (ibfd, isec));
462       return;
463     }
464
465   /* Compare section address range with user-requested
466      address range (if any).  Compute where the actual
467      transfer should start and end.  */
468   if (sec_start < data->load_start)
469     sec_offset = data->load_start - sec_start;
470   /* Size of a partial transfer.  */
471   sec_load_count -= sec_offset;
472   if (data->load_end > 0 && sec_end > data->load_end)
473     sec_load_count -= sec_end - data->load_end;
474
475   /* Get the data.  */
476   buf = xmalloc (size);
477   old_chain = make_cleanup (xfree, buf);
478   if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
479     error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd), 
480            bfd_errmsg (bfd_get_error ()));
481
482   printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
483                    bfd_section_name (ibfd, isec), 
484                    (unsigned long) sec_start, 
485                    (unsigned long) sec_end);
486
487   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
488     printf_filtered (" into memory (%s to %s)\n",
489                      paddress (target_gdbarch (),
490                                (unsigned long) sec_start
491                                + sec_offset + data->load_offset), 
492                      paddress (target_gdbarch (),
493                                (unsigned long) sec_start + sec_offset
494                                 + data->load_offset + sec_load_count));
495   else
496     puts_filtered ("\n");
497
498   /* Write the data.  */
499   ret = target_write_memory (sec_start + sec_offset + data->load_offset, 
500                              buf + sec_offset, sec_load_count);
501   if (ret != 0)
502     warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
503   do_cleanups (old_chain);
504   return;
505 }
506
507 static void
508 restore_binary_file (char *filename, struct callback_data *data)
509 {
510   FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
511   gdb_byte *buf;
512   long len;
513
514   /* Get the file size for reading.  */
515   if (fseek (file, 0, SEEK_END) == 0)
516     {
517       len = ftell (file);
518       if (len < 0)
519         perror_with_name (filename);
520     }
521   else
522     perror_with_name (filename);
523
524   if (len <= data->load_start)
525     error (_("Start address is greater than length of binary file %s."), 
526            filename);
527
528   /* Chop off "len" if it exceeds the requested load_end addr.  */
529   if (data->load_end != 0 && data->load_end < len)
530     len = data->load_end;
531   /* Chop off "len" if the requested load_start addr skips some bytes.  */
532   if (data->load_start > 0)
533     len -= data->load_start;
534
535   printf_filtered 
536     ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n", 
537      filename, 
538      (unsigned long) (data->load_start + data->load_offset),
539      (unsigned long) (data->load_start + data->load_offset + len));
540
541   /* Now set the file pos to the requested load start pos.  */
542   if (fseek (file, data->load_start, SEEK_SET) != 0)
543     perror_with_name (filename);
544
545   /* Now allocate a buffer and read the file contents.  */
546   buf = xmalloc (len);
547   make_cleanup (xfree, buf);
548   if (fread (buf, 1, len, file) != len)
549     perror_with_name (filename);
550
551   /* Now write the buffer into target memory.  */
552   len = target_write_memory (data->load_start + data->load_offset, buf, len);
553   if (len != 0)
554     warning (_("restore: memory write failed (%s)."), safe_strerror (len));
555   return;
556 }
557
558 static void
559 restore_command (char *args, int from_tty)
560 {
561   char *filename;
562   struct callback_data data;
563   bfd *ibfd;
564   int binary_flag = 0;
565
566   if (!target_has_execution)
567     noprocess ();
568
569   data.load_offset = 0;
570   data.load_start  = 0;
571   data.load_end    = 0;
572
573   /* Parse the input arguments.  First is filename (required).  */
574   filename = scan_filename_with_cleanup (&args, NULL);
575   if (args != NULL && *args != '\0')
576     {
577       char *binary_string = "binary";
578
579       /* Look for optional "binary" flag.  */
580       if (strncmp (args, binary_string, strlen (binary_string)) == 0)
581         {
582           binary_flag = 1;
583           args += strlen (binary_string);
584           args = skip_spaces (args);
585         }
586       /* Parse offset (optional).  */
587       if (args != NULL && *args != '\0')
588       data.load_offset = 
589         parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
590       if (args != NULL && *args != '\0')
591         {
592           /* Parse start address (optional).  */
593           data.load_start = 
594             parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
595           if (args != NULL && *args != '\0')
596             {
597               /* Parse end address (optional).  */
598               data.load_end = parse_and_eval_long (args);
599               if (data.load_end <= data.load_start)
600                 error (_("Start must be less than end."));
601             }
602         }
603     }
604
605   if (info_verbose)
606     printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
607                      filename, (unsigned long) data.load_offset, 
608                      (unsigned long) data.load_start, 
609                      (unsigned long) data.load_end);
610
611   if (binary_flag)
612     {
613       restore_binary_file (filename, &data);
614     }
615   else
616     {
617       /* Open the file for loading.  */
618       ibfd = bfd_openr_with_cleanup (filename, NULL);
619
620       /* Process the sections.  */
621       bfd_map_over_sections (ibfd, restore_section_callback, &data);
622     }
623   return;
624 }
625
626 static void
627 srec_dump_command (char *cmd, int from_tty)
628 {
629   printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
630   help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
631 }
632
633 static void
634 ihex_dump_command (char *cmd, int from_tty)
635 {
636   printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
637   help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
638 }
639
640 static void
641 tekhex_dump_command (char *cmd, int from_tty)
642 {
643   printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
644   help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
645 }
646
647 static void
648 binary_dump_command (char *cmd, int from_tty)
649 {
650   printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
651   help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
652 }
653
654 static void
655 binary_append_command (char *cmd, int from_tty)
656 {
657   printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
658   help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
659 }
660
661 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
662
663 void
664 _initialize_cli_dump (void)
665 {
666   struct cmd_list_element *c;
667
668   add_prefix_cmd ("dump", class_vars, dump_command,
669                   _("Dump target code/data to a local file."),
670                   &dump_cmdlist, "dump ",
671                   0/*allow-unknown*/,
672                   &cmdlist);
673   add_prefix_cmd ("append", class_vars, append_command,
674                   _("Append target code/data to a local file."),
675                   &append_cmdlist, "append ",
676                   0/*allow-unknown*/,
677                   &cmdlist);
678
679   add_dump_command ("memory", dump_memory_command, "\
680 Write contents of memory to a raw binary file.\n\
681 Arguments are FILE START STOP.  Writes the contents of memory within the\n\
682 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
683
684   add_dump_command ("value", dump_value_command, "\
685 Write the value of an expression to a raw binary file.\n\
686 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION to\n\
687 the specified FILE in raw target ordered bytes.");
688
689   add_prefix_cmd ("srec", all_commands, srec_dump_command,
690                   _("Write target code/data to an srec file."),
691                   &srec_cmdlist, "dump srec ", 
692                   0 /*allow-unknown*/, 
693                   &dump_cmdlist);
694
695   add_prefix_cmd ("ihex", all_commands, ihex_dump_command,
696                   _("Write target code/data to an intel hex file."),
697                   &ihex_cmdlist, "dump ihex ", 
698                   0 /*allow-unknown*/, 
699                   &dump_cmdlist);
700
701   add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command,
702                   _("Write target code/data to a tekhex file."),
703                   &tekhex_cmdlist, "dump tekhex ", 
704                   0 /*allow-unknown*/, 
705                   &dump_cmdlist);
706
707   add_prefix_cmd ("binary", all_commands, binary_dump_command,
708                   _("Write target code/data to a raw binary file."),
709                   &binary_dump_cmdlist, "dump binary ", 
710                   0 /*allow-unknown*/, 
711                   &dump_cmdlist);
712
713   add_prefix_cmd ("binary", all_commands, binary_append_command,
714                   _("Append target code/data to a raw binary file."),
715                   &binary_append_cmdlist, "append binary ", 
716                   0 /*allow-unknown*/, 
717                   &append_cmdlist);
718
719   add_cmd ("memory", all_commands, dump_srec_memory, _("\
720 Write contents of memory to an srec file.\n\
721 Arguments are FILE START STOP.  Writes the contents of memory\n\
722 within the range [START .. STOP) to the specified FILE in srec format."),
723            &srec_cmdlist);
724
725   add_cmd ("value", all_commands, dump_srec_value, _("\
726 Write the value of an expression to an srec file.\n\
727 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
728 to the specified FILE in srec format."),
729            &srec_cmdlist);
730
731   add_cmd ("memory", all_commands, dump_ihex_memory, _("\
732 Write contents of memory to an ihex file.\n\
733 Arguments are FILE START STOP.  Writes the contents of memory within\n\
734 the range [START .. STOP) to the specified FILE in intel hex format."),
735            &ihex_cmdlist);
736
737   add_cmd ("value", all_commands, dump_ihex_value, _("\
738 Write the value of an expression to an ihex file.\n\
739 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
740 to the specified FILE in intel hex format."),
741            &ihex_cmdlist);
742
743   add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
744 Write contents of memory to a tekhex file.\n\
745 Arguments are FILE START STOP.  Writes the contents of memory\n\
746 within the range [START .. STOP) to the specified FILE in tekhex format."),
747            &tekhex_cmdlist);
748
749   add_cmd ("value", all_commands, dump_tekhex_value, _("\
750 Write the value of an expression to a tekhex file.\n\
751 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
752 to the specified FILE in tekhex format."),
753            &tekhex_cmdlist);
754
755   add_cmd ("memory", all_commands, dump_binary_memory, _("\
756 Write contents of memory to a raw binary file.\n\
757 Arguments are FILE START STOP.  Writes the contents of memory\n\
758 within the range [START .. STOP) to the specified FILE in binary format."),
759            &binary_dump_cmdlist);
760
761   add_cmd ("value", all_commands, dump_binary_value, _("\
762 Write the value of an expression to a raw binary file.\n\
763 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
764 to the specified FILE in raw target ordered bytes."),
765            &binary_dump_cmdlist);
766
767   add_cmd ("memory", all_commands, append_binary_memory, _("\
768 Append contents of memory to a raw binary file.\n\
769 Arguments are FILE START STOP.  Writes the contents of memory within the\n\
770 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
771            &binary_append_cmdlist);
772
773   add_cmd ("value", all_commands, append_binary_value, _("\
774 Append the value of an expression to a raw binary file.\n\
775 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
776 to the specified FILE in raw target ordered bytes."),
777            &binary_append_cmdlist);
778
779   c = add_com ("restore", class_vars, restore_command, _("\
780 Restore the contents of FILE to target memory.\n\
781 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
782 OFFSET will be added to the base address of the file (default zero).\n\
783 If START and END are given, only the file contents within that range\n\
784 (file relative) will be restored to target memory."));
785   c->completer = filename_completer;
786   /* FIXME: completers for other commands.  */
787 }