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