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/>. */
23 #include "cli/cli-decode.h"
24 #include "cli/cli-cmds.h"
26 #include "completer.h"
29 #include "readline/readline.h"
31 #include "cli/cli-utils.h"
33 #include "filestuff.h"
37 scan_expression_with_cleanup (const char **cmd
, const char *def
)
39 if ((*cmd
) == NULL
|| (**cmd
) == '\0')
41 char *exp
= xstrdup (def
);
43 make_cleanup (xfree
, exp
);
51 end
= (*cmd
) + strcspn (*cmd
, " \t");
52 exp
= savestring ((*cmd
), end
- (*cmd
));
53 make_cleanup (xfree
, exp
);
54 (*cmd
) = skip_spaces_const (end
);
61 scan_filename_with_cleanup (const char **cmd
, const char *defname
)
66 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
72 error (_("Missing filename."));
73 filename
= xstrdup (defname
);
74 make_cleanup (xfree
, filename
);
78 /* FIXME: should parse a possibly quoted string. */
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
);
87 gdb_assert (filename
!= NULL
);
89 fullname
= tilde_expand (filename
);
90 make_cleanup (xfree
, fullname
);
96 fopen_with_cleanup (const char *filename
, const char *mode
)
98 FILE *file
= gdb_fopen_cloexec (filename
, mode
);
101 perror_with_name (filename
);
102 make_cleanup_fclose (file
);
107 bfd_openr_with_cleanup (const char *filename
, const char *target
)
111 ibfd
= gdb_bfd_openr (filename
, target
);
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
);
124 bfd_openw_with_cleanup (const char *filename
, const char *target
,
129 if (*mode
== 'w') /* Write: create new file */
131 obfd
= gdb_bfd_openw (filename
, target
);
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 ()));
139 else if (*mode
== 'a') /* Append to existing file. */
140 { /* FIXME -- doesn't work... */
141 error (_("bfd_openw does not work with append."));
144 error (_("bfd_openw_with_cleanup: unknown mode %s."), mode
);
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
*verilog_cmdlist
;
154 static struct cmd_list_element
*tekhex_cmdlist
;
155 static struct cmd_list_element
*binary_dump_cmdlist
;
156 static struct cmd_list_element
*binary_append_cmdlist
;
159 dump_command (char *cmd
, int from_tty
)
161 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
162 help_list (dump_cmdlist
, "dump ", all_commands
, gdb_stdout
);
166 append_command (char *cmd
, int from_tty
)
168 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
169 help_list (dump_cmdlist
, "append ", all_commands
, gdb_stdout
);
173 dump_binary_file (const char *filename
, const char *mode
,
174 const bfd_byte
*buf
, ULONGEST len
)
179 file
= fopen_with_cleanup (filename
, mode
);
180 status
= fwrite (buf
, len
, 1, file
);
182 perror_with_name (filename
);
186 dump_bfd_file (const char *filename
, const char *mode
,
187 const char *target
, CORE_ADDR vaddr
,
188 const bfd_byte
*buf
, ULONGEST len
)
193 obfd
= bfd_openw_with_cleanup (filename
, target
, mode
);
194 osection
= bfd_make_section_anyway (obfd
, ".newsec");
195 bfd_set_section_size (obfd
, osection
, len
);
196 bfd_set_section_vma (obfd
, osection
, vaddr
);
197 bfd_set_section_alignment (obfd
, osection
, 0);
198 bfd_set_section_flags (obfd
, osection
, (SEC_HAS_CONTENTS
201 osection
->entsize
= 0;
202 if (!bfd_set_section_contents (obfd
, osection
, buf
, 0, len
))
203 warning (_("writing dump file '%s' (%s)"), filename
,
204 bfd_errmsg (bfd_get_error ()));
208 dump_memory_to_file (const char *cmd
, const char *mode
, const char *file_format
)
210 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
214 const char *filename
;
220 filename
= scan_filename_with_cleanup (&cmd
, NULL
);
222 /* Find the low address. */
223 if (cmd
== NULL
|| *cmd
== '\0')
224 error (_("Missing start address."));
225 lo_exp
= scan_expression_with_cleanup (&cmd
, NULL
);
227 /* Find the second address - rest of line. */
228 if (cmd
== NULL
|| *cmd
== '\0')
229 error (_("Missing stop address."));
232 lo
= parse_and_eval_address (lo_exp
);
233 hi
= parse_and_eval_address (hi_exp
);
235 error (_("Invalid memory address range (start >= end)."));
238 /* FIXME: Should use read_memory_partial() and a magic blocking
240 buf
= xmalloc (count
);
241 make_cleanup (xfree
, buf
);
242 read_memory (lo
, buf
, count
);
244 /* Have everything. Open/write the data. */
245 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
247 dump_binary_file (filename
, mode
, buf
, count
);
251 dump_bfd_file (filename
, mode
, file_format
, lo
, buf
, count
);
254 do_cleanups (old_cleanups
);
258 dump_memory_command (char *cmd
, char *mode
)
260 dump_memory_to_file (cmd
, mode
, "binary");
264 dump_value_to_file (const char *cmd
, const char *mode
, const char *file_format
)
266 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
268 const char *filename
;
271 filename
= scan_filename_with_cleanup (&cmd
, NULL
);
273 /* Find the value. */
274 if (cmd
== NULL
|| *cmd
== '\0')
275 error (_("No value to %s."), *mode
== 'a' ? "append" : "dump");
276 val
= parse_and_eval (cmd
);
278 error (_("Invalid expression."));
280 /* Have everything. Open/write the data. */
281 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
283 dump_binary_file (filename
, mode
, value_contents (val
),
284 TYPE_LENGTH (value_type (val
)));
290 if (VALUE_LVAL (val
))
292 vaddr
= value_address (val
);
297 warning (_("value is not an lval: address assumed to be zero"));
300 dump_bfd_file (filename
, mode
, file_format
, vaddr
,
301 value_contents (val
),
302 TYPE_LENGTH (value_type (val
)));
305 do_cleanups (old_cleanups
);
309 dump_value_command (char *cmd
, char *mode
)
311 dump_value_to_file (cmd
, mode
, "binary");
315 dump_srec_memory (char *args
, int from_tty
)
317 dump_memory_to_file (args
, FOPEN_WB
, "srec");
321 dump_srec_value (char *args
, int from_tty
)
323 dump_value_to_file (args
, FOPEN_WB
, "srec");
327 dump_ihex_memory (char *args
, int from_tty
)
329 dump_memory_to_file (args
, FOPEN_WB
, "ihex");
333 dump_ihex_value (char *args
, int from_tty
)
335 dump_value_to_file (args
, FOPEN_WB
, "ihex");
339 dump_verilog_memory (char *args
, int from_tty
)
341 dump_memory_to_file (args
, FOPEN_WB
, "verilog");
345 dump_verilog_value (char *args
, int from_tty
)
347 dump_value_to_file (args
, FOPEN_WB
, "verilog");
351 dump_tekhex_memory (char *args
, int from_tty
)
353 dump_memory_to_file (args
, FOPEN_WB
, "tekhex");
357 dump_tekhex_value (char *args
, int from_tty
)
359 dump_value_to_file (args
, FOPEN_WB
, "tekhex");
363 dump_binary_memory (char *args
, int from_tty
)
365 dump_memory_to_file (args
, FOPEN_WB
, "binary");
369 dump_binary_value (char *args
, int from_tty
)
371 dump_value_to_file (args
, FOPEN_WB
, "binary");
375 append_binary_memory (char *args
, int from_tty
)
377 dump_memory_to_file (args
, FOPEN_AB
, "binary");
381 append_binary_value (char *args
, int from_tty
)
383 dump_value_to_file (args
, FOPEN_AB
, "binary");
388 void (*func
) (char *cmd
, char *mode
);
393 call_dump_func (struct cmd_list_element
*c
, char *args
, int from_tty
)
395 struct dump_context
*d
= get_cmd_context (c
);
397 d
->func (args
, d
->mode
);
401 add_dump_command (char *name
, void (*func
) (char *args
, char *mode
),
405 struct cmd_list_element
*c
;
406 struct dump_context
*d
;
408 c
= add_cmd (name
, all_commands
, NULL
, descr
, &dump_cmdlist
);
409 c
->completer
= filename_completer
;
410 d
= XNEW (struct dump_context
);
413 set_cmd_context (c
, d
);
414 c
->func
= call_dump_func
;
416 c
= add_cmd (name
, all_commands
, NULL
, descr
, &append_cmdlist
);
417 c
->completer
= filename_completer
;
418 d
= XNEW (struct dump_context
);
421 set_cmd_context (c
, d
);
422 c
->func
= call_dump_func
;
424 /* Replace "Dump " at start of docstring with "Append " (borrowed
425 from [deleted] deprecated_add_show_from_set). */
426 if ( c
->doc
[0] == 'W'
432 c
->doc
= concat ("Append ", c
->doc
+ 6, (char *)NULL
);
435 /* Opaque data for restore_section_callback. */
436 struct callback_data
{
437 CORE_ADDR load_offset
;
438 CORE_ADDR load_start
;
442 /* Function: restore_section_callback.
444 Callback function for bfd_map_over_sections.
445 Selectively loads the sections into memory. */
448 restore_section_callback (bfd
*ibfd
, asection
*isec
, void *args
)
450 struct callback_data
*data
= args
;
451 bfd_vma sec_start
= bfd_section_vma (ibfd
, isec
);
452 bfd_size_type size
= bfd_section_size (ibfd
, isec
);
453 bfd_vma sec_end
= sec_start
+ size
;
454 bfd_size_type sec_offset
= 0;
455 bfd_size_type sec_load_count
= size
;
456 struct cleanup
*old_chain
;
460 /* Ignore non-loadable sections, eg. from elf files. */
461 if (!(bfd_get_section_flags (ibfd
, isec
) & SEC_LOAD
))
464 /* Does the section overlap with the desired restore range? */
465 if (sec_end
<= data
->load_start
466 || (data
->load_end
> 0 && sec_start
>= data
->load_end
))
468 /* No, no useable data in this section. */
469 printf_filtered (_("skipping section %s...\n"),
470 bfd_section_name (ibfd
, isec
));
474 /* Compare section address range with user-requested
475 address range (if any). Compute where the actual
476 transfer should start and end. */
477 if (sec_start
< data
->load_start
)
478 sec_offset
= data
->load_start
- sec_start
;
479 /* Size of a partial transfer. */
480 sec_load_count
-= sec_offset
;
481 if (data
->load_end
> 0 && sec_end
> data
->load_end
)
482 sec_load_count
-= sec_end
- data
->load_end
;
485 buf
= (gdb_byte
*) xmalloc (size
);
486 old_chain
= make_cleanup (xfree
, buf
);
487 if (!bfd_get_section_contents (ibfd
, isec
, buf
, 0, size
))
488 error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd
),
489 bfd_errmsg (bfd_get_error ()));
491 printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
492 bfd_section_name (ibfd
, isec
),
493 (unsigned long) sec_start
,
494 (unsigned long) sec_end
);
496 if (data
->load_offset
!= 0 || data
->load_start
!= 0 || data
->load_end
!= 0)
497 printf_filtered (" into memory (%s to %s)\n",
498 paddress (target_gdbarch (),
499 (unsigned long) sec_start
500 + sec_offset
+ data
->load_offset
),
501 paddress (target_gdbarch (),
502 (unsigned long) sec_start
+ sec_offset
503 + data
->load_offset
+ sec_load_count
));
505 puts_filtered ("\n");
507 /* Write the data. */
508 ret
= target_write_memory (sec_start
+ sec_offset
+ data
->load_offset
,
509 buf
+ sec_offset
, sec_load_count
);
511 warning (_("restore: memory write failed (%s)."), safe_strerror (ret
));
512 do_cleanups (old_chain
);
517 restore_binary_file (const char *filename
, struct callback_data
*data
)
519 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
520 FILE *file
= fopen_with_cleanup (filename
, FOPEN_RB
);
524 /* Get the file size for reading. */
525 if (fseek (file
, 0, SEEK_END
) == 0)
529 perror_with_name (filename
);
532 perror_with_name (filename
);
534 if (len
<= data
->load_start
)
535 error (_("Start address is greater than length of binary file %s."),
538 /* Chop off "len" if it exceeds the requested load_end addr. */
539 if (data
->load_end
!= 0 && data
->load_end
< len
)
540 len
= data
->load_end
;
541 /* Chop off "len" if the requested load_start addr skips some bytes. */
542 if (data
->load_start
> 0)
543 len
-= data
->load_start
;
546 ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
548 (unsigned long) (data
->load_start
+ data
->load_offset
),
549 (unsigned long) (data
->load_start
+ data
->load_offset
+ len
));
551 /* Now set the file pos to the requested load start pos. */
552 if (fseek (file
, data
->load_start
, SEEK_SET
) != 0)
553 perror_with_name (filename
);
555 /* Now allocate a buffer and read the file contents. */
556 buf
= (gdb_byte
*) xmalloc (len
);
557 make_cleanup (xfree
, buf
);
558 if (fread (buf
, 1, len
, file
) != len
)
559 perror_with_name (filename
);
561 /* Now write the buffer into target memory. */
562 len
= target_write_memory (data
->load_start
+ data
->load_offset
, buf
, len
);
564 warning (_("restore: memory write failed (%s)."), safe_strerror (len
));
565 do_cleanups (cleanup
);
569 restore_command (char *args_in
, int from_tty
)
572 struct callback_data data
;
575 const char *args
= args_in
;
577 if (!target_has_execution
)
580 data
.load_offset
= 0;
584 /* Parse the input arguments. First is filename (required). */
585 filename
= scan_filename_with_cleanup (&args
, NULL
);
586 if (args
!= NULL
&& *args
!= '\0')
588 char *binary_string
= "binary";
590 /* Look for optional "binary" flag. */
591 if (startswith (args
, binary_string
))
594 args
+= strlen (binary_string
);
595 args
= skip_spaces_const (args
);
597 /* Parse offset (optional). */
598 if (args
!= NULL
&& *args
!= '\0')
600 parse_and_eval_address (scan_expression_with_cleanup (&args
, NULL
));
601 if (args
!= NULL
&& *args
!= '\0')
603 /* Parse start address (optional). */
605 parse_and_eval_long (scan_expression_with_cleanup (&args
, NULL
));
606 if (args
!= NULL
&& *args
!= '\0')
608 /* Parse end address (optional). */
609 data
.load_end
= parse_and_eval_long (args
);
610 if (data
.load_end
<= data
.load_start
)
611 error (_("Start must be less than end."));
617 printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
618 filename
, (unsigned long) data
.load_offset
,
619 (unsigned long) data
.load_start
,
620 (unsigned long) data
.load_end
);
624 restore_binary_file (filename
, &data
);
628 /* Open the file for loading. */
629 ibfd
= bfd_openr_with_cleanup (filename
, NULL
);
631 /* Process the sections. */
632 bfd_map_over_sections (ibfd
, restore_section_callback
, &data
);
638 srec_dump_command (char *cmd
, int from_tty
)
640 printf_unfiltered (_("\"dump srec\" must be followed by a subcommand.\n"));
641 help_list (srec_cmdlist
, "dump srec ", all_commands
, gdb_stdout
);
645 ihex_dump_command (char *cmd
, int from_tty
)
647 printf_unfiltered (_("\"dump ihex\" must be followed by a subcommand.\n"));
648 help_list (ihex_cmdlist
, "dump ihex ", all_commands
, gdb_stdout
);
652 verilog_dump_command (char *cmd
, int from_tty
)
654 printf_unfiltered (_("\"dump verilog\" must be followed by a subcommand.\n"));
655 help_list (verilog_cmdlist
, "dump verilog ", all_commands
, gdb_stdout
);
659 tekhex_dump_command (char *cmd
, int from_tty
)
661 printf_unfiltered (_("\"dump tekhex\" must be followed by a subcommand.\n"));
662 help_list (tekhex_cmdlist
, "dump tekhex ", all_commands
, gdb_stdout
);
666 binary_dump_command (char *cmd
, int from_tty
)
668 printf_unfiltered (_("\"dump binary\" must be followed by a subcommand.\n"));
669 help_list (binary_dump_cmdlist
, "dump binary ", all_commands
, gdb_stdout
);
673 binary_append_command (char *cmd
, int from_tty
)
675 printf_unfiltered (_("\"append binary\" must be followed by a subcommand.\n"));
676 help_list (binary_append_cmdlist
, "append binary ", all_commands
,
680 extern initialize_file_ftype _initialize_cli_dump
; /* -Wmissing-prototypes */
683 _initialize_cli_dump (void)
685 struct cmd_list_element
*c
;
687 add_prefix_cmd ("dump", class_vars
, dump_command
,
688 _("Dump target code/data to a local file."),
689 &dump_cmdlist
, "dump ",
692 add_prefix_cmd ("append", class_vars
, append_command
,
693 _("Append target code/data to a local file."),
694 &append_cmdlist
, "append ",
698 add_dump_command ("memory", dump_memory_command
, "\
699 Write contents of memory to a raw binary file.\n\
700 Arguments are FILE START STOP. Writes the contents of memory within the\n\
701 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
703 add_dump_command ("value", dump_value_command
, "\
704 Write the value of an expression to a raw binary file.\n\
705 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
706 the specified FILE in raw target ordered bytes.");
708 add_prefix_cmd ("srec", all_commands
, srec_dump_command
,
709 _("Write target code/data to an srec file."),
710 &srec_cmdlist
, "dump srec ",
714 add_prefix_cmd ("ihex", all_commands
, ihex_dump_command
,
715 _("Write target code/data to an intel hex file."),
716 &ihex_cmdlist
, "dump ihex ",
720 add_prefix_cmd ("verilog", all_commands
, verilog_dump_command
,
721 _("Write target code/data to a verilog hex file."),
722 &verilog_cmdlist
, "dump verilog ",
726 add_prefix_cmd ("tekhex", all_commands
, tekhex_dump_command
,
727 _("Write target code/data to a tekhex file."),
728 &tekhex_cmdlist
, "dump tekhex ",
732 add_prefix_cmd ("binary", all_commands
, binary_dump_command
,
733 _("Write target code/data to a raw binary file."),
734 &binary_dump_cmdlist
, "dump binary ",
738 add_prefix_cmd ("binary", all_commands
, binary_append_command
,
739 _("Append target code/data to a raw binary file."),
740 &binary_append_cmdlist
, "append binary ",
744 add_cmd ("memory", all_commands
, dump_srec_memory
, _("\
745 Write contents of memory to an srec file.\n\
746 Arguments are FILE START STOP. Writes the contents of memory\n\
747 within the range [START .. STOP) to the specified FILE in srec format."),
750 add_cmd ("value", all_commands
, dump_srec_value
, _("\
751 Write the value of an expression to an srec file.\n\
752 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
753 to the specified FILE in srec format."),
756 add_cmd ("memory", all_commands
, dump_ihex_memory
, _("\
757 Write contents of memory to an ihex file.\n\
758 Arguments are FILE START STOP. Writes the contents of memory within\n\
759 the range [START .. STOP) to the specified FILE in intel hex format."),
762 add_cmd ("value", all_commands
, dump_ihex_value
, _("\
763 Write the value of an expression to an ihex file.\n\
764 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
765 to the specified FILE in intel hex format."),
768 add_cmd ("memory", all_commands
, dump_verilog_memory
, _("\
769 Write contents of memory to a verilog hex file.\n\
770 Arguments are FILE START STOP. Writes the contents of memory within\n\
771 the range [START .. STOP) to the specified FILE in verilog hex format."),
774 add_cmd ("value", all_commands
, dump_verilog_value
, _("\
775 Write the value of an expression to a verilog hex file.\n\
776 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
777 to the specified FILE in verilog hex format."),
780 add_cmd ("memory", all_commands
, dump_tekhex_memory
, _("\
781 Write contents of memory to a tekhex file.\n\
782 Arguments are FILE START STOP. Writes the contents of memory\n\
783 within the range [START .. STOP) to the specified FILE in tekhex format."),
786 add_cmd ("value", all_commands
, dump_tekhex_value
, _("\
787 Write the value of an expression to a tekhex file.\n\
788 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
789 to the specified FILE in tekhex format."),
792 add_cmd ("memory", all_commands
, dump_binary_memory
, _("\
793 Write contents of memory to a raw binary file.\n\
794 Arguments are FILE START STOP. Writes the contents of memory\n\
795 within the range [START .. STOP) to the specified FILE in binary format."),
796 &binary_dump_cmdlist
);
798 add_cmd ("value", all_commands
, dump_binary_value
, _("\
799 Write the value of an expression to a raw binary file.\n\
800 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
801 to the specified FILE in raw target ordered bytes."),
802 &binary_dump_cmdlist
);
804 add_cmd ("memory", all_commands
, append_binary_memory
, _("\
805 Append contents of memory to a raw binary file.\n\
806 Arguments are FILE START STOP. Writes the contents of memory within the\n\
807 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
808 &binary_append_cmdlist
);
810 add_cmd ("value", all_commands
, append_binary_value
, _("\
811 Append the value of an expression to a raw binary file.\n\
812 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
813 to the specified FILE in raw target ordered bytes."),
814 &binary_append_cmdlist
);
816 c
= add_com ("restore", class_vars
, restore_command
, _("\
817 Restore the contents of FILE to target memory.\n\
818 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
819 OFFSET will be added to the base address of the file (default zero).\n\
820 If START and END are given, only the file contents within that range\n\
821 (file relative) will be restored to target memory."));
822 c
->completer
= filename_completer
;
823 /* FIXME: completers for other commands. */