2010-05-17 Michael Snyder <msnyder@vmware.com>
[deliverable/binutils-gdb.git] / gdb / cli / cli-dump.c
CommitLineData
f02df580
MS
1/* Dump-to-file commands, for GDB, the GNU debugger.
2
4c38e0a4
JB
3 Copyright (c) 2002, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
f02df580
MS
5
6 Contributed by Red Hat.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
a9762ec7 12 the Free Software Foundation; either version 3 of the License, or
f02df580
MS
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
a9762ec7 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
f02df580
MS
22
23#include "defs.h"
24#include "gdb_string.h"
25#include "cli/cli-decode.h"
26#include "cli/cli-cmds.h"
27#include "value.h"
28#include "completer.h"
29#include "cli/cli-dump.h"
30#include "gdb_assert.h"
31#include <ctype.h>
32#include "target.h"
dbda9972 33#include "readline/readline.h"
c0ac0ec7 34#include "gdbcore.h"
f02df580
MS
35
36#define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
37
38
39char *
40skip_spaces (char *chp)
41{
42 if (chp == NULL)
43 return NULL;
44 while (isspace (*chp))
45 chp++;
46 return chp;
47}
48
49char *
50scan_expression_with_cleanup (char **cmd, const char *def)
51{
52 if ((*cmd) == NULL || (**cmd) == '\0')
53 {
54 char *exp = xstrdup (def);
55 make_cleanup (xfree, exp);
56 return exp;
57 }
58 else
59 {
60 char *exp;
61 char *end;
62
63 end = (*cmd) + strcspn (*cmd, " \t");
64 exp = savestring ((*cmd), end - (*cmd));
65 make_cleanup (xfree, exp);
66 (*cmd) = skip_spaces (end);
67 return exp;
68 }
69}
70
71
f02df580
MS
72char *
73scan_filename_with_cleanup (char **cmd, const char *defname)
74{
75 char *filename;
76 char *fullname;
77
78 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
79
80 /* File. */
81 if ((*cmd) == NULL)
82 {
83 if (defname == NULL)
8a3fe4f8 84 error (_("Missing filename."));
f02df580
MS
85 filename = xstrdup (defname);
86 make_cleanup (xfree, filename);
87 }
88 else
89 {
90 /* FIXME: should parse a possibly quoted string. */
91 char *end;
92
93 (*cmd) = skip_spaces (*cmd);
94 end = *cmd + strcspn (*cmd, " \t");
95 filename = savestring ((*cmd), end - (*cmd));
96 make_cleanup (xfree, filename);
97 (*cmd) = skip_spaces (end);
98 }
99 gdb_assert (filename != NULL);
100
101 fullname = tilde_expand (filename);
102 make_cleanup (xfree, fullname);
103
104 return fullname;
105}
106
107FILE *
c26b8e3b 108fopen_with_cleanup (const char *filename, const char *mode)
f02df580
MS
109{
110 FILE *file = fopen (filename, mode);
111 if (file == NULL)
112 perror_with_name (filename);
113 make_cleanup_fclose (file);
114 return file;
115}
116
117static bfd *
118bfd_openr_with_cleanup (const char *filename, const char *target)
119{
120 bfd *ibfd;
121
5cb316ef
AC
122 ibfd = bfd_openr (filename, target);
123 if (ibfd == NULL)
8a3fe4f8 124 error (_("Failed to open %s: %s."), filename,
f02df580
MS
125 bfd_errmsg (bfd_get_error ()));
126
127 make_cleanup_bfd_close (ibfd);
128 if (!bfd_check_format (ibfd, bfd_object))
8a3fe4f8 129 error (_("'%s' is not a recognized file format."), filename);
f02df580
MS
130
131 return ibfd;
132}
133
134static bfd *
c26b8e3b
AC
135bfd_openw_with_cleanup (const char *filename, const char *target,
136 const char *mode)
f02df580
MS
137{
138 bfd *obfd;
139
140 if (*mode == 'w') /* Write: create new file */
141 {
5cb316ef
AC
142 obfd = bfd_openw (filename, target);
143 if (obfd == NULL)
8a3fe4f8 144 error (_("Failed to open %s: %s."), filename,
f02df580
MS
145 bfd_errmsg (bfd_get_error ()));
146 make_cleanup_bfd_close (obfd);
147 if (!bfd_set_format (obfd, bfd_object))
8a3fe4f8 148 error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
f02df580
MS
149 }
150 else if (*mode == 'a') /* Append to existing file */
151 { /* FIXME -- doesn't work... */
8a3fe4f8 152 error (_("bfd_openw does not work with append."));
f02df580
MS
153 }
154 else
8a3fe4f8 155 error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
f02df580
MS
156
157 return obfd;
158}
159
160struct cmd_list_element *dump_cmdlist;
161struct cmd_list_element *append_cmdlist;
162struct cmd_list_element *srec_cmdlist;
163struct cmd_list_element *ihex_cmdlist;
164struct cmd_list_element *tekhex_cmdlist;
165struct cmd_list_element *binary_dump_cmdlist;
166struct cmd_list_element *binary_append_cmdlist;
167
168static void
169dump_command (char *cmd, int from_tty)
170{
a3f17187 171 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
f02df580
MS
172 help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
173}
174
175static void
176append_command (char *cmd, int from_tty)
177{
a3f17187 178 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
f02df580
MS
179 help_list (dump_cmdlist, "append ", -1, gdb_stdout);
180}
181
182static void
c26b8e3b
AC
183dump_binary_file (const char *filename, const char *mode,
184 const bfd_byte *buf, int len)
f02df580
MS
185{
186 FILE *file;
187 int status;
188
189 file = fopen_with_cleanup (filename, mode);
190 status = fwrite (buf, len, 1, file);
191 if (status != 1)
192 perror_with_name (filename);
193}
194
195static void
c26b8e3b
AC
196dump_bfd_file (const char *filename, const char *mode,
197 const char *target, CORE_ADDR vaddr,
198 const bfd_byte *buf, int len)
f02df580
MS
199{
200 bfd *obfd;
201 asection *osection;
202
203 obfd = bfd_openw_with_cleanup (filename, target, mode);
204 osection = bfd_make_section_anyway (obfd, ".newsec");
205 bfd_set_section_size (obfd, osection, len);
206 bfd_set_section_vma (obfd, osection, vaddr);
207 bfd_set_section_alignment (obfd, osection, 0);
e9c55a7b
AC
208 bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
209 | SEC_ALLOC
210 | SEC_LOAD));
f02df580
MS
211 osection->entsize = 0;
212 bfd_set_section_contents (obfd, osection, buf, 0, len);
213}
214
215static void
216dump_memory_to_file (char *cmd, char *mode, char *file_format)
217{
218 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
219 CORE_ADDR lo;
220 CORE_ADDR hi;
221 ULONGEST count;
222 char *filename;
223 void *buf;
224 char *lo_exp;
225 char *hi_exp;
f02df580
MS
226
227 /* Open the file. */
228 filename = scan_filename_with_cleanup (&cmd, NULL);
229
230 /* Find the low address. */
231 if (cmd == NULL || *cmd == '\0')
8a3fe4f8 232 error (_("Missing start address."));
f02df580
MS
233 lo_exp = scan_expression_with_cleanup (&cmd, NULL);
234
235 /* Find the second address - rest of line. */
236 if (cmd == NULL || *cmd == '\0')
8a3fe4f8 237 error (_("Missing stop address."));
f02df580
MS
238 hi_exp = cmd;
239
240 lo = parse_and_eval_address (lo_exp);
241 hi = parse_and_eval_address (hi_exp);
242 if (hi <= lo)
8a3fe4f8 243 error (_("Invalid memory address range (start >= end)."));
f02df580
MS
244 count = hi - lo;
245
246 /* FIXME: Should use read_memory_partial() and a magic blocking
247 value. */
248 buf = xmalloc (count);
249 make_cleanup (xfree, buf);
c0ac0ec7 250 read_memory (lo, buf, count);
f02df580
MS
251
252 /* Have everything. Open/write the data. */
253 if (file_format == NULL || strcmp (file_format, "binary") == 0)
254 {
255 dump_binary_file (filename, mode, buf, count);
256 }
257 else
258 {
259 dump_bfd_file (filename, mode, file_format, lo, buf, count);
260 }
261
262 do_cleanups (old_cleanups);
263}
264
265static void
266dump_memory_command (char *cmd, char *mode)
267{
268 dump_memory_to_file (cmd, mode, "binary");
269}
270
271static void
272dump_value_to_file (char *cmd, char *mode, char *file_format)
273{
274 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
275 struct value *val;
276 char *filename;
277
278 /* Open the file. */
279 filename = scan_filename_with_cleanup (&cmd, NULL);
280
281 /* Find the value. */
282 if (cmd == NULL || *cmd == '\0')
8a3fe4f8 283 error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
f02df580
MS
284 val = parse_and_eval (cmd);
285 if (val == NULL)
8a3fe4f8 286 error (_("Invalid expression."));
f02df580
MS
287
288 /* Have everything. Open/write the data. */
289 if (file_format == NULL || strcmp (file_format, "binary") == 0)
290 {
0fd88904 291 dump_binary_file (filename, mode, value_contents (val),
df407dfe 292 TYPE_LENGTH (value_type (val)));
f02df580
MS
293 }
294 else
295 {
296 CORE_ADDR vaddr;
297
298 if (VALUE_LVAL (val))
299 {
42ae5230 300 vaddr = value_address (val);
f02df580
MS
301 }
302 else
303 {
304 vaddr = 0;
8a3fe4f8 305 warning (_("value is not an lval: address assumed to be zero"));
f02df580
MS
306 }
307
308 dump_bfd_file (filename, mode, file_format, vaddr,
0fd88904 309 value_contents (val),
df407dfe 310 TYPE_LENGTH (value_type (val)));
f02df580
MS
311 }
312
313 do_cleanups (old_cleanups);
314}
315
316static void
317dump_value_command (char *cmd, char *mode)
318{
319 dump_value_to_file (cmd, mode, "binary");
320}
321
f02df580
MS
322static void
323dump_srec_memory (char *args, int from_tty)
324{
5d1d95de 325 dump_memory_to_file (args, FOPEN_WB, "srec");
f02df580
MS
326}
327
328static void
329dump_srec_value (char *args, int from_tty)
330{
5d1d95de 331 dump_value_to_file (args, FOPEN_WB, "srec");
f02df580
MS
332}
333
334static void
335dump_ihex_memory (char *args, int from_tty)
336{
5d1d95de 337 dump_memory_to_file (args, FOPEN_WB, "ihex");
f02df580
MS
338}
339
340static void
341dump_ihex_value (char *args, int from_tty)
342{
5d1d95de 343 dump_value_to_file (args, FOPEN_WB, "ihex");
f02df580
MS
344}
345
346static void
347dump_tekhex_memory (char *args, int from_tty)
348{
5d1d95de 349 dump_memory_to_file (args, FOPEN_WB, "tekhex");
f02df580
MS
350}
351
352static void
353dump_tekhex_value (char *args, int from_tty)
354{
5d1d95de 355 dump_value_to_file (args, FOPEN_WB, "tekhex");
f02df580
MS
356}
357
358static void
359dump_binary_memory (char *args, int from_tty)
360{
5d1d95de 361 dump_memory_to_file (args, FOPEN_WB, "binary");
f02df580
MS
362}
363
364static void
365dump_binary_value (char *args, int from_tty)
366{
5d1d95de 367 dump_value_to_file (args, FOPEN_WB, "binary");
f02df580
MS
368}
369
370static void
371append_binary_memory (char *args, int from_tty)
372{
5d1d95de 373 dump_memory_to_file (args, FOPEN_AB, "binary");
f02df580
MS
374}
375
376static void
377append_binary_value (char *args, int from_tty)
378{
5d1d95de 379 dump_value_to_file (args, FOPEN_AB, "binary");
f02df580
MS
380}
381
382struct dump_context
383{
384 void (*func) (char *cmd, char *mode);
385 char *mode;
386};
387
388static void
389call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
390{
391 struct dump_context *d = get_cmd_context (c);
392 d->func (args, d->mode);
393}
394
395void
396add_dump_command (char *name, void (*func) (char *args, char *mode),
397 char *descr)
398
399{
400 struct cmd_list_element *c;
401 struct dump_context *d;
402
403 c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
404 c->completer = filename_completer;
405 d = XMALLOC (struct dump_context);
406 d->func = func;
5d1d95de 407 d->mode = FOPEN_WB;
f02df580
MS
408 set_cmd_context (c, d);
409 c->func = call_dump_func;
410
411 c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
412 c->completer = filename_completer;
413 d = XMALLOC (struct dump_context);
414 d->func = func;
5d1d95de 415 d->mode = FOPEN_AB;
f02df580
MS
416 set_cmd_context (c, d);
417 c->func = call_dump_func;
418
cb1a6d5f 419 /* Replace "Dump " at start of docstring with "Append " (borrowed
eefe576e 420 from [deleted] deprecated_add_show_from_set). */
f02df580
MS
421 if ( c->doc[0] == 'W'
422 && c->doc[1] == 'r'
423 && c->doc[2] == 'i'
424 && c->doc[3] == 't'
425 && c->doc[4] == 'e'
426 && c->doc[5] == ' ')
1754f103 427 c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
f02df580
MS
428}
429
430/* Opaque data for restore_section_callback. */
431struct callback_data {
1fac167a 432 CORE_ADDR load_offset;
f02df580
MS
433 CORE_ADDR load_start;
434 CORE_ADDR load_end;
435};
436
437/* Function: restore_section_callback.
438
439 Callback function for bfd_map_over_sections.
440 Selectively loads the sections into memory. */
441
442static void
443restore_section_callback (bfd *ibfd, asection *isec, void *args)
444{
445 struct callback_data *data = args;
446 bfd_vma sec_start = bfd_section_vma (ibfd, isec);
447 bfd_size_type size = bfd_section_size (ibfd, isec);
448 bfd_vma sec_end = sec_start + size;
449 bfd_size_type sec_offset = 0;
450 bfd_size_type sec_load_count = size;
451 struct cleanup *old_chain;
47b667de 452 gdb_byte *buf;
f02df580
MS
453 int ret;
454
455 /* Ignore non-loadable sections, eg. from elf files. */
456 if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
457 return;
458
459 /* Does the section overlap with the desired restore range? */
460 if (sec_end <= data->load_start
461 || (data->load_end > 0 && sec_start >= data->load_end))
462 {
463 /* No, no useable data in this section. */
a3f17187 464 printf_filtered (_("skipping section %s...\n"),
f02df580
MS
465 bfd_section_name (ibfd, isec));
466 return;
467 }
468
469 /* Compare section address range with user-requested
470 address range (if any). Compute where the actual
471 transfer should start and end. */
472 if (sec_start < data->load_start)
473 sec_offset = data->load_start - sec_start;
474 /* Size of a partial transfer: */
475 sec_load_count -= sec_offset;
476 if (data->load_end > 0 && sec_end > data->load_end)
477 sec_load_count -= sec_end - data->load_end;
478
479 /* Get the data. */
480 buf = xmalloc (size);
481 old_chain = make_cleanup (xfree, buf);
482 if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
8a3fe4f8 483 error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
f02df580
MS
484 bfd_errmsg (bfd_get_error ()));
485
486 printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
487 bfd_section_name (ibfd, isec),
488 (unsigned long) sec_start,
489 (unsigned long) sec_end);
490
491 if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
5af949e3
UW
492 printf_filtered (" into memory (%s to %s)\n",
493 paddress (target_gdbarch,
494 (unsigned long) sec_start
f5db4da3 495 + sec_offset + data->load_offset),
5af949e3
UW
496 paddress (target_gdbarch,
497 (unsigned long) sec_start + sec_offset
498 + data->load_offset + sec_load_count));
f02df580
MS
499 else
500 puts_filtered ("\n");
501
502 /* Write the data. */
503 ret = target_write_memory (sec_start + sec_offset + data->load_offset,
504 buf + sec_offset, sec_load_count);
505 if (ret != 0)
8a3fe4f8 506 warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
f02df580
MS
507 do_cleanups (old_chain);
508 return;
509}
510
511static void
512restore_binary_file (char *filename, struct callback_data *data)
513{
5d1d95de 514 FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
47b667de 515 gdb_byte *buf;
f02df580
MS
516 long len;
517
518 /* Get the file size for reading. */
519 if (fseek (file, 0, SEEK_END) == 0)
520 len = ftell (file);
521 else
522 perror_with_name (filename);
523
524 if (len <= data->load_start)
8a3fe4f8 525 error (_("Start address is greater than length of binary file %s."),
f02df580
MS
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,
1fac167a
UW
538 (unsigned long) (data->load_start + data->load_offset),
539 (unsigned long) (data->load_start + data->load_offset + len));
f02df580
MS
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)
8a3fe4f8 554 warning (_("restore: memory write failed (%s)."), safe_strerror (len));
f02df580
MS
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
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 =
1fac167a 589 parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
f02df580
MS
590 if (args != NULL && *args != '\0')
591 {
592 /* Parse start address (optional). */
593 data.load_start =
de530e84 594 parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
f02df580
MS
595 if (args != NULL && *args != '\0')
596 {
597 /* Parse end address (optional). */
de530e84 598 data.load_end = parse_and_eval_long (args);
f02df580 599 if (data.load_end <= data.load_start)
8a3fe4f8 600 error (_("Start must be less than end."));
f02df580
MS
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
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
b9362cc7
AC
661extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
662
f02df580
MS
663void
664_initialize_cli_dump (void)
665{
666 struct cmd_list_element *c;
1bedd215
AC
667 add_prefix_cmd ("dump", class_vars, dump_command, _("\
668Dump target code/data to a local file."),
f02df580
MS
669 &dump_cmdlist, "dump ",
670 0/*allow-unknown*/,
671 &cmdlist);
1bedd215
AC
672 add_prefix_cmd ("append", class_vars, append_command, _("\
673Append target code/data to a local file."),
f02df580
MS
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 specifed 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
1bedd215
AC
688 add_prefix_cmd ("srec", all_commands, srec_dump_command, _("\
689Write target code/data to an srec file."),
f02df580
MS
690 &srec_cmdlist, "dump srec ",
691 0 /*allow-unknown*/,
692 &dump_cmdlist);
693
1bedd215
AC
694 add_prefix_cmd ("ihex", all_commands, ihex_dump_command, _("\
695Write target code/data to an intel hex file."),
f02df580
MS
696 &ihex_cmdlist, "dump ihex ",
697 0 /*allow-unknown*/,
698 &dump_cmdlist);
699
1bedd215
AC
700 add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command, _("\
701Write target code/data to a tekhex file."),
f02df580
MS
702 &tekhex_cmdlist, "dump tekhex ",
703 0 /*allow-unknown*/,
704 &dump_cmdlist);
705
1bedd215
AC
706 add_prefix_cmd ("binary", all_commands, binary_dump_command, _("\
707Write target code/data to a raw binary file."),
f02df580
MS
708 &binary_dump_cmdlist, "dump binary ",
709 0 /*allow-unknown*/,
710 &dump_cmdlist);
711
1bedd215
AC
712 add_prefix_cmd ("binary", all_commands, binary_append_command, _("\
713Append target code/data to a raw binary file."),
f02df580
MS
714 &binary_append_cmdlist, "append binary ",
715 0 /*allow-unknown*/,
716 &append_cmdlist);
717
1a966eab 718 add_cmd ("memory", all_commands, dump_srec_memory, _("\
f02df580
MS
719Write contents of memory to an srec file.\n\
720Arguments are FILE START STOP. Writes the contents of memory\n\
1a966eab 721within the range [START .. STOP) to the specifed FILE in srec format."),
f02df580
MS
722 &srec_cmdlist);
723
1a966eab 724 add_cmd ("value", all_commands, dump_srec_value, _("\
f02df580
MS
725Write the value of an expression to an srec file.\n\
726Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
1a966eab 727to the specified FILE in srec format."),
f02df580
MS
728 &srec_cmdlist);
729
1a966eab 730 add_cmd ("memory", all_commands, dump_ihex_memory, _("\
f02df580
MS
731Write contents of memory to an ihex file.\n\
732Arguments are FILE START STOP. Writes the contents of memory within\n\
1a966eab 733the range [START .. STOP) to the specifed FILE in intel hex format."),
f02df580
MS
734 &ihex_cmdlist);
735
1a966eab 736 add_cmd ("value", all_commands, dump_ihex_value, _("\
f02df580
MS
737Write the value of an expression to an ihex file.\n\
738Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
1a966eab 739to the specified FILE in intel hex format."),
f02df580
MS
740 &ihex_cmdlist);
741
1a966eab 742 add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
f02df580
MS
743Write contents of memory to a tekhex file.\n\
744Arguments are FILE START STOP. Writes the contents of memory\n\
1a966eab 745within the range [START .. STOP) to the specifed FILE in tekhex format."),
f02df580
MS
746 &tekhex_cmdlist);
747
1a966eab 748 add_cmd ("value", all_commands, dump_tekhex_value, _("\
f02df580
MS
749Write the value of an expression to a tekhex file.\n\
750Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
1a966eab 751to the specified FILE in tekhex format."),
f02df580
MS
752 &tekhex_cmdlist);
753
1a966eab 754 add_cmd ("memory", all_commands, dump_binary_memory, _("\
f02df580
MS
755Write contents of memory to a raw binary file.\n\
756Arguments are FILE START STOP. Writes the contents of memory\n\
1a966eab 757within the range [START .. STOP) to the specifed FILE in binary format."),
f02df580
MS
758 &binary_dump_cmdlist);
759
1a966eab 760 add_cmd ("value", all_commands, dump_binary_value, _("\
f02df580
MS
761Write the value of an expression to a raw binary file.\n\
762Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
1a966eab 763to the specified FILE in raw target ordered bytes."),
f02df580
MS
764 &binary_dump_cmdlist);
765
1a966eab 766 add_cmd ("memory", all_commands, append_binary_memory, _("\
f02df580
MS
767Append contents of memory to a raw binary file.\n\
768Arguments are FILE START STOP. Writes the contents of memory within the\n\
1a966eab 769range [START .. STOP) to the specifed FILE in raw target ordered bytes."),
f02df580
MS
770 &binary_append_cmdlist);
771
1a966eab 772 add_cmd ("value", all_commands, append_binary_value, _("\
f02df580
MS
773Append the value of an expression to a raw binary file.\n\
774Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
1a966eab 775to the specified FILE in raw target ordered bytes."),
f02df580
MS
776 &binary_append_cmdlist);
777
1bedd215
AC
778 c = add_com ("restore", class_vars, restore_command, _("\
779Restore the contents of FILE to target memory.\n\
f02df580
MS
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\
9eb6e5a1 782If START and END are given, only the file contents within that range\n\
1bedd215 783(file relative) will be restored to target memory."));
f02df580
MS
784 c->completer = filename_completer;
785 /* FIXME: completers for other commands. */
786}
This page took 0.540093 seconds and 4 git commands to generate.