Automatic date update in version.in
[deliverable/binutils-gdb.git] / gdb / cli / cli-dump.c
... / ...
CommitLineData
1/* Dump-to-file commands, for GDB, the GNU debugger.
2
3 Copyright (C) 2002-2015 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 "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"
34
35
36static const char *
37scan_expression_with_cleanup (const char **cmd, const char *def)
38{
39 if ((*cmd) == NULL || (**cmd) == '\0')
40 {
41 char *exp = xstrdup (def);
42
43 make_cleanup (xfree, exp);
44 return exp;
45 }
46 else
47 {
48 char *exp;
49 const char *end;
50
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}
58
59
60static char *
61scan_filename_with_cleanup (const char **cmd, const char *defname)
62{
63 char *filename;
64 char *fullname;
65
66 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
67
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;
80
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);
88
89 fullname = tilde_expand (filename);
90 make_cleanup (xfree, fullname);
91
92 return fullname;
93}
94
95static FILE *
96fopen_with_cleanup (const char *filename, const char *mode)
97{
98 FILE *file = gdb_fopen_cloexec (filename, mode);
99
100 if (file == NULL)
101 perror_with_name (filename);
102 make_cleanup_fclose (file);
103 return file;
104}
105
106static bfd *
107bfd_openr_with_cleanup (const char *filename, const char *target)
108{
109 bfd *ibfd;
110
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 ()));
115
116 make_cleanup_bfd_unref (ibfd);
117 if (!bfd_check_format (ibfd, bfd_object))
118 error (_("'%s' is not a recognized file format."), filename);
119
120 return ibfd;
121}
122
123static bfd *
124bfd_openw_with_cleanup (const char *filename, const char *target,
125 const char *mode)
126{
127 bfd *obfd;
128
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);
145
146 return obfd;
147}
148
149static struct cmd_list_element *dump_cmdlist;
150static struct cmd_list_element *append_cmdlist;
151static struct cmd_list_element *srec_cmdlist;
152static struct cmd_list_element *ihex_cmdlist;
153static struct cmd_list_element *tekhex_cmdlist;
154static struct cmd_list_element *binary_dump_cmdlist;
155static struct cmd_list_element *binary_append_cmdlist;
156
157static void
158dump_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}
163
164static void
165append_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}
170
171static void
172dump_binary_file (const char *filename, const char *mode,
173 const bfd_byte *buf, ULONGEST len)
174{
175 FILE *file;
176 int status;
177
178 file = fopen_with_cleanup (filename, mode);
179 status = fwrite (buf, len, 1, file);
180 if (status != 1)
181 perror_with_name (filename);
182}
183
184static void
185dump_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;
191
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}
205
206static void
207dump_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;
217
218 /* Open the file. */
219 filename = scan_filename_with_cleanup (&cmd, NULL);
220
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);
225
226 /* Find the second address - rest of line. */
227 if (cmd == NULL || *cmd == '\0')
228 error (_("Missing stop address."));
229 hi_exp = cmd;
230
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;
236
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);
242
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 }
252
253 do_cleanups (old_cleanups);
254}
255
256static void
257dump_memory_command (char *cmd, char *mode)
258{
259 dump_memory_to_file (cmd, mode, "binary");
260}
261
262static void
263dump_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;
268
269 /* Open the file. */
270 filename = scan_filename_with_cleanup (&cmd, NULL);
271
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."));
278
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;
288
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 }
298
299 dump_bfd_file (filename, mode, file_format, vaddr,
300 value_contents (val),
301 TYPE_LENGTH (value_type (val)));
302 }
303
304 do_cleanups (old_cleanups);
305}
306
307static void
308dump_value_command (char *cmd, char *mode)
309{
310 dump_value_to_file (cmd, mode, "binary");
311}
312
313static void
314dump_srec_memory (char *args, int from_tty)
315{
316 dump_memory_to_file (args, FOPEN_WB, "srec");
317}
318
319static void
320dump_srec_value (char *args, int from_tty)
321{
322 dump_value_to_file (args, FOPEN_WB, "srec");
323}
324
325static void
326dump_ihex_memory (char *args, int from_tty)
327{
328 dump_memory_to_file (args, FOPEN_WB, "ihex");
329}
330
331static void
332dump_ihex_value (char *args, int from_tty)
333{
334 dump_value_to_file (args, FOPEN_WB, "ihex");
335}
336
337static void
338dump_tekhex_memory (char *args, int from_tty)
339{
340 dump_memory_to_file (args, FOPEN_WB, "tekhex");
341}
342
343static void
344dump_tekhex_value (char *args, int from_tty)
345{
346 dump_value_to_file (args, FOPEN_WB, "tekhex");
347}
348
349static void
350dump_binary_memory (char *args, int from_tty)
351{
352 dump_memory_to_file (args, FOPEN_WB, "binary");
353}
354
355static void
356dump_binary_value (char *args, int from_tty)
357{
358 dump_value_to_file (args, FOPEN_WB, "binary");
359}
360
361static void
362append_binary_memory (char *args, int from_tty)
363{
364 dump_memory_to_file (args, FOPEN_AB, "binary");
365}
366
367static void
368append_binary_value (char *args, int from_tty)
369{
370 dump_value_to_file (args, FOPEN_AB, "binary");
371}
372
373struct dump_context
374{
375 void (*func) (char *cmd, char *mode);
376 char *mode;
377};
378
379static void
380call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
381{
382 struct dump_context *d = get_cmd_context (c);
383
384 d->func (args, d->mode);
385}
386
387static void
388add_dump_command (char *name, void (*func) (char *args, char *mode),
389 char *descr)
390
391{
392 struct cmd_list_element *c;
393 struct dump_context *d;
394
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;
402
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;
410
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}
421
422/* Opaque data for restore_section_callback. */
423struct callback_data {
424 CORE_ADDR load_offset;
425 CORE_ADDR load_start;
426 CORE_ADDR load_end;
427};
428
429/* Function: restore_section_callback.
430
431 Callback function for bfd_map_over_sections.
432 Selectively loads the sections into memory. */
433
434static void
435restore_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;
446
447 /* Ignore non-loadable sections, eg. from elf files. */
448 if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
449 return;
450
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 }
460
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;
470
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 ()));
477
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);
482
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");
493
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}
502
503static void
504restore_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;
510
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);
520
521 if (len <= data->load_start)
522 error (_("Start address is greater than length of binary file %s."),
523 filename);
524
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;
531
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));
537
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);
541
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);
547
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}
554
555static void
556restore_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;
563
564 if (!target_has_execution)
565 noprocess ();
566
567 data.load_offset = 0;
568 data.load_start = 0;
569 data.load_end = 0;
570
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";
576
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 }
602
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);
608
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);
617
618 /* Process the sections. */
619 bfd_map_over_sections (ibfd, restore_section_callback, &data);
620 }
621 return;
622}
623
624static void
625srec_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}
630
631static void
632ihex_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}
637
638static void
639tekhex_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}
644
645static void
646binary_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}
651
652static void
653binary_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}
659
660extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
661
662void
663_initialize_cli_dump (void)
664{
665 struct cmd_list_element *c;
666
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);
677
678 add_dump_command ("memory", dump_memory_command, "\
679Write contents of memory to a raw binary file.\n\
680Arguments are FILE START STOP. Writes the contents of memory within the\n\
681range [START .. STOP) to the specified FILE in raw target ordered bytes.");
682
683 add_dump_command ("value", dump_value_command, "\
684Write the value of an expression to a raw binary file.\n\
685Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
686the specified FILE in raw target ordered bytes.");
687
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);
693
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);
699
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);
705
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);
711
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);
717
718 add_cmd ("memory", all_commands, dump_srec_memory, _("\
719Write contents of memory to an srec file.\n\
720Arguments are FILE START STOP. Writes the contents of memory\n\
721within the range [START .. STOP) to the specified FILE in srec format."),
722 &srec_cmdlist);
723
724 add_cmd ("value", all_commands, dump_srec_value, _("\
725Write the value of an expression to an srec file.\n\
726Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
727to the specified FILE in srec format."),
728 &srec_cmdlist);
729
730 add_cmd ("memory", all_commands, dump_ihex_memory, _("\
731Write contents of memory to an ihex file.\n\
732Arguments are FILE START STOP. Writes the contents of memory within\n\
733the range [START .. STOP) to the specified FILE in intel hex format."),
734 &ihex_cmdlist);
735
736 add_cmd ("value", all_commands, dump_ihex_value, _("\
737Write the value of an expression to an ihex file.\n\
738Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
739to the specified FILE in intel hex format."),
740 &ihex_cmdlist);
741
742 add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
743Write contents of memory to a tekhex file.\n\
744Arguments are FILE START STOP. Writes the contents of memory\n\
745within the range [START .. STOP) to the specified FILE in tekhex format."),
746 &tekhex_cmdlist);
747
748 add_cmd ("value", all_commands, dump_tekhex_value, _("\
749Write the value of an expression to a tekhex file.\n\
750Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
751to the specified FILE in tekhex format."),
752 &tekhex_cmdlist);
753
754 add_cmd ("memory", all_commands, dump_binary_memory, _("\
755Write contents of memory to a raw binary file.\n\
756Arguments are FILE START STOP. Writes the contents of memory\n\
757within the range [START .. STOP) to the specified FILE in binary format."),
758 &binary_dump_cmdlist);
759
760 add_cmd ("value", all_commands, dump_binary_value, _("\
761Write the value of an expression to a raw binary file.\n\
762Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
763to the specified FILE in raw target ordered bytes."),
764 &binary_dump_cmdlist);
765
766 add_cmd ("memory", all_commands, append_binary_memory, _("\
767Append contents of memory to a raw binary file.\n\
768Arguments are FILE START STOP. Writes the contents of memory within the\n\
769range [START .. STOP) to the specified FILE in raw target ordered bytes."),
770 &binary_append_cmdlist);
771
772 add_cmd ("value", all_commands, append_binary_value, _("\
773Append the value of an expression to a raw binary file.\n\
774Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
775to the specified FILE in raw target ordered bytes."),
776 &binary_append_cmdlist);
777
778 c = add_com ("restore", class_vars, restore_command, _("\
779Restore the contents of FILE to target memory.\n\
780Arguments are FILE OFFSET START END where all except FILE are optional.\n\
781OFFSET will be added to the base address of the file (default zero).\n\
782If 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}
This page took 0.025006 seconds and 4 git commands to generate.