Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / cli / cli-dump.c
CommitLineData
5796c8dc
SS
1/* Dump-to-file commands, for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 2002-2013 Free Software Foundation, Inc.
5796c8dc
SS
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"
c50c785c 34#include "cli/cli-utils.h"
ef5ccd6c 35#include "gdb_bfd.h"
5796c8dc
SS
36
37#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
38
39
5796c8dc
SS
40char *
41scan_expression_with_cleanup (char **cmd, const char *def)
42{
43 if ((*cmd) == NULL || (**cmd) == '\0')
44 {
45 char *exp = xstrdup (def);
cf7f2e2d 46
5796c8dc
SS
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
64char *
65scan_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
99FILE *
100fopen_with_cleanup (const char *filename, const char *mode)
101{
102 FILE *file = fopen (filename, mode);
cf7f2e2d 103
5796c8dc
SS
104 if (file == NULL)
105 perror_with_name (filename);
106 make_cleanup_fclose (file);
107 return file;
108}
109
110static bfd *
111bfd_openr_with_cleanup (const char *filename, const char *target)
112{
113 bfd *ibfd;
114
ef5ccd6c 115 ibfd = gdb_bfd_openr (filename, target);
5796c8dc
SS
116 if (ibfd == NULL)
117 error (_("Failed to open %s: %s."), filename,
118 bfd_errmsg (bfd_get_error ()));
119
ef5ccd6c 120 make_cleanup_bfd_unref (ibfd);
5796c8dc
SS
121 if (!bfd_check_format (ibfd, bfd_object))
122 error (_("'%s' is not a recognized file format."), filename);
123
124 return ibfd;
125}
126
127static bfd *
128bfd_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 {
ef5ccd6c 135 obfd = gdb_bfd_openw (filename, target);
5796c8dc
SS
136 if (obfd == NULL)
137 error (_("Failed to open %s: %s."), filename,
138 bfd_errmsg (bfd_get_error ()));
ef5ccd6c 139 make_cleanup_bfd_unref (obfd);
5796c8dc
SS
140 if (!bfd_set_format (obfd, bfd_object))
141 error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
142 }
c50c785c
JM
143 else if (*mode == 'a') /* Append to existing file. */
144 { /* FIXME -- doesn't work... */
5796c8dc
SS
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
ef5ccd6c
JM
153static struct cmd_list_element *dump_cmdlist;
154static struct cmd_list_element *append_cmdlist;
155static struct cmd_list_element *srec_cmdlist;
156static struct cmd_list_element *ihex_cmdlist;
157static struct cmd_list_element *tekhex_cmdlist;
158static struct cmd_list_element *binary_dump_cmdlist;
159static struct cmd_list_element *binary_append_cmdlist;
5796c8dc
SS
160
161static void
162dump_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
168static void
169append_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
175static void
176dump_binary_file (const char *filename, const char *mode,
a45ae5f8 177 const bfd_byte *buf, ULONGEST len)
5796c8dc
SS
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
188static void
189dump_bfd_file (const char *filename, const char *mode,
190 const char *target, CORE_ADDR vaddr,
a45ae5f8 191 const bfd_byte *buf, ULONGEST len)
5796c8dc
SS
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;
c50c785c
JM
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 ()));
5796c8dc
SS
208}
209
210static void
211dump_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;
5796c8dc
SS
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
260static void
261dump_memory_command (char *cmd, char *mode)
262{
263 dump_memory_to_file (cmd, mode, "binary");
264}
265
266static void
267dump_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
311static void
312dump_value_command (char *cmd, char *mode)
313{
314 dump_value_to_file (cmd, mode, "binary");
315}
316
317static void
318dump_srec_memory (char *args, int from_tty)
319{
320 dump_memory_to_file (args, FOPEN_WB, "srec");
321}
322
323static void
324dump_srec_value (char *args, int from_tty)
325{
326 dump_value_to_file (args, FOPEN_WB, "srec");
327}
328
329static void
330dump_ihex_memory (char *args, int from_tty)
331{
332 dump_memory_to_file (args, FOPEN_WB, "ihex");
333}
334
335static void
336dump_ihex_value (char *args, int from_tty)
337{
338 dump_value_to_file (args, FOPEN_WB, "ihex");
339}
340
341static void
342dump_tekhex_memory (char *args, int from_tty)
343{
344 dump_memory_to_file (args, FOPEN_WB, "tekhex");
345}
346
347static void
348dump_tekhex_value (char *args, int from_tty)
349{
350 dump_value_to_file (args, FOPEN_WB, "tekhex");
351}
352
353static void
354dump_binary_memory (char *args, int from_tty)
355{
356 dump_memory_to_file (args, FOPEN_WB, "binary");
357}
358
359static void
360dump_binary_value (char *args, int from_tty)
361{
362 dump_value_to_file (args, FOPEN_WB, "binary");
363}
364
365static void
366append_binary_memory (char *args, int from_tty)
367{
368 dump_memory_to_file (args, FOPEN_AB, "binary");
369}
370
371static void
372append_binary_value (char *args, int from_tty)
373{
374 dump_value_to_file (args, FOPEN_AB, "binary");
375}
376
377struct dump_context
378{
379 void (*func) (char *cmd, char *mode);
380 char *mode;
381};
382
383static void
384call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
385{
386 struct dump_context *d = get_cmd_context (c);
cf7f2e2d 387
5796c8dc
SS
388 d->func (args, d->mode);
389}
390
391void
392add_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
c50c785c 426/* Opaque data for restore_section_callback. */
5796c8dc
SS
427struct 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
438static void
439restore_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
c50c785c 451 /* Ignore non-loadable sections, eg. from elf files. */
5796c8dc
SS
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 {
c50c785c 459 /* No, no useable data in this section. */
5796c8dc
SS
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;
c50c785c 470 /* Size of a partial transfer. */
5796c8dc
SS
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",
ef5ccd6c 489 paddress (target_gdbarch (),
5796c8dc
SS
490 (unsigned long) sec_start
491 + sec_offset + data->load_offset),
ef5ccd6c 492 paddress (target_gdbarch (),
5796c8dc
SS
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
507static void
508restore_binary_file (char *filename, struct callback_data *data)
509{
510 FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
5796c8dc
SS
511 gdb_byte *buf;
512 long len;
513
514 /* Get the file size for reading. */
515 if (fseek (file, 0, SEEK_END) == 0)
c50c785c
JM
516 {
517 len = ftell (file);
518 if (len < 0)
519 perror_with_name (filename);
520 }
5796c8dc
SS
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
c50c785c 528 /* Chop off "len" if it exceeds the requested load_end addr. */
5796c8dc
SS
529 if (data->load_end != 0 && data->load_end < len)
530 len = data->load_end;
c50c785c 531 /* Chop off "len" if the requested load_start addr skips some bytes. */
5796c8dc
SS
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
c50c785c 551 /* Now write the buffer into target memory. */
5796c8dc
SS
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
558static void
559restore_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
c50c785c 573 /* Parse the input arguments. First is filename (required). */
5796c8dc
SS
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 }
c50c785c 586 /* Parse offset (optional). */
5796c8dc
SS
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 {
c50c785c 592 /* Parse start address (optional). */
5796c8dc
SS
593 data.load_start =
594 parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
595 if (args != NULL && *args != '\0')
596 {
c50c785c 597 /* Parse end address (optional). */
5796c8dc
SS
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 {
c50c785c 617 /* Open the file for loading. */
5796c8dc
SS
618 ibfd = bfd_openr_with_cleanup (filename, NULL);
619
c50c785c 620 /* Process the sections. */
5796c8dc
SS
621 bfd_map_over_sections (ibfd, restore_section_callback, &data);
622 }
623 return;
624}
625
626static void
627srec_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
633static void
634ihex_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
640static void
641tekhex_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
647static void
648binary_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
654static void
655binary_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
661extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
662
663void
664_initialize_cli_dump (void)
665{
666 struct cmd_list_element *c;
cf7f2e2d 667
c50c785c
JM
668 add_prefix_cmd ("dump", class_vars, dump_command,
669 _("Dump target code/data to a local file."),
5796c8dc
SS
670 &dump_cmdlist, "dump ",
671 0/*allow-unknown*/,
672 &cmdlist);
c50c785c
JM
673 add_prefix_cmd ("append", class_vars, append_command,
674 _("Append target code/data to a local file."),
5796c8dc
SS
675 &append_cmdlist, "append ",
676 0/*allow-unknown*/,
677 &cmdlist);
678
679 add_dump_command ("memory", dump_memory_command, "\
680Write contents of memory to a raw binary file.\n\
681Arguments are FILE START STOP. Writes the contents of memory within the\n\
a45ae5f8 682range [START .. STOP) to the specified FILE in raw target ordered bytes.");
5796c8dc
SS
683
684 add_dump_command ("value", dump_value_command, "\
685Write the value of an expression to a raw binary file.\n\
686Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
687the specified FILE in raw target ordered bytes.");
688
c50c785c
JM
689 add_prefix_cmd ("srec", all_commands, srec_dump_command,
690 _("Write target code/data to an srec file."),
5796c8dc
SS
691 &srec_cmdlist, "dump srec ",
692 0 /*allow-unknown*/,
693 &dump_cmdlist);
694
c50c785c
JM
695 add_prefix_cmd ("ihex", all_commands, ihex_dump_command,
696 _("Write target code/data to an intel hex file."),
5796c8dc
SS
697 &ihex_cmdlist, "dump ihex ",
698 0 /*allow-unknown*/,
699 &dump_cmdlist);
700
c50c785c
JM
701 add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command,
702 _("Write target code/data to a tekhex file."),
5796c8dc
SS
703 &tekhex_cmdlist, "dump tekhex ",
704 0 /*allow-unknown*/,
705 &dump_cmdlist);
706
c50c785c
JM
707 add_prefix_cmd ("binary", all_commands, binary_dump_command,
708 _("Write target code/data to a raw binary file."),
5796c8dc
SS
709 &binary_dump_cmdlist, "dump binary ",
710 0 /*allow-unknown*/,
711 &dump_cmdlist);
712
c50c785c
JM
713 add_prefix_cmd ("binary", all_commands, binary_append_command,
714 _("Append target code/data to a raw binary file."),
5796c8dc
SS
715 &binary_append_cmdlist, "append binary ",
716 0 /*allow-unknown*/,
717 &append_cmdlist);
718
719 add_cmd ("memory", all_commands, dump_srec_memory, _("\
720Write contents of memory to an srec file.\n\
721Arguments are FILE START STOP. Writes the contents of memory\n\
a45ae5f8 722within the range [START .. STOP) to the specified FILE in srec format."),
5796c8dc
SS
723 &srec_cmdlist);
724
725 add_cmd ("value", all_commands, dump_srec_value, _("\
726Write the value of an expression to an srec file.\n\
727Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
728to the specified FILE in srec format."),
729 &srec_cmdlist);
730
731 add_cmd ("memory", all_commands, dump_ihex_memory, _("\
732Write contents of memory to an ihex file.\n\
733Arguments are FILE START STOP. Writes the contents of memory within\n\
a45ae5f8 734the range [START .. STOP) to the specified FILE in intel hex format."),
5796c8dc
SS
735 &ihex_cmdlist);
736
737 add_cmd ("value", all_commands, dump_ihex_value, _("\
738Write the value of an expression to an ihex file.\n\
739Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
740to the specified FILE in intel hex format."),
741 &ihex_cmdlist);
742
743 add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
744Write contents of memory to a tekhex file.\n\
745Arguments are FILE START STOP. Writes the contents of memory\n\
a45ae5f8 746within the range [START .. STOP) to the specified FILE in tekhex format."),
5796c8dc
SS
747 &tekhex_cmdlist);
748
749 add_cmd ("value", all_commands, dump_tekhex_value, _("\
750Write the value of an expression to a tekhex file.\n\
751Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
752to the specified FILE in tekhex format."),
753 &tekhex_cmdlist);
754
755 add_cmd ("memory", all_commands, dump_binary_memory, _("\
756Write contents of memory to a raw binary file.\n\
757Arguments are FILE START STOP. Writes the contents of memory\n\
a45ae5f8 758within the range [START .. STOP) to the specified FILE in binary format."),
5796c8dc
SS
759 &binary_dump_cmdlist);
760
761 add_cmd ("value", all_commands, dump_binary_value, _("\
762Write the value of an expression to a raw binary file.\n\
763Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
764to the specified FILE in raw target ordered bytes."),
765 &binary_dump_cmdlist);
766
767 add_cmd ("memory", all_commands, append_binary_memory, _("\
768Append contents of memory to a raw binary file.\n\
769Arguments are FILE START STOP. Writes the contents of memory within the\n\
a45ae5f8 770range [START .. STOP) to the specified FILE in raw target ordered bytes."),
5796c8dc
SS
771 &binary_append_cmdlist);
772
773 add_cmd ("value", all_commands, append_binary_value, _("\
774Append the value of an expression to a raw binary file.\n\
775Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
776to the specified FILE in raw target ordered bytes."),
777 &binary_append_cmdlist);
778
779 c = add_com ("restore", class_vars, restore_command, _("\
780Restore the contents of FILE to target memory.\n\
781Arguments are FILE OFFSET START END where all except FILE are optional.\n\
782OFFSET will be added to the base address of the file (default zero).\n\
783If 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;
c50c785c 786 /* FIXME: completers for other commands. */
5796c8dc 787}