1 /* Dump-to-file commands, for GDB, the GNU debugger.
3 Copyright (c) 2002, 2005, 2007, 2008, 2009 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 "gdb_string.h"
24 #include "cli/cli-decode.h"
25 #include "cli/cli-cmds.h"
27 #include "completer.h"
28 #include "cli/cli-dump.h"
29 #include "gdb_assert.h"
32 #include "readline/readline.h"
34 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
38 skip_spaces (char *chp)
42 while (isspace (*chp))
48 scan_expression_with_cleanup (char **cmd, const char *def)
50 if ((*cmd) == NULL || (**cmd) == '\0')
52 char *exp = xstrdup (def);
53 make_cleanup (xfree, exp);
61 end = (*cmd) + strcspn (*cmd, " \t");
62 exp = savestring ((*cmd), end - (*cmd));
63 make_cleanup (xfree, exp);
64 (*cmd) = skip_spaces (end);
71 scan_filename_with_cleanup (char **cmd, const char *defname)
76 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
82 error (_("Missing filename."));
83 filename = xstrdup (defname);
84 make_cleanup (xfree, filename);
88 /* FIXME: should parse a possibly quoted string. */
91 (*cmd) = skip_spaces (*cmd);
92 end = *cmd + strcspn (*cmd, " \t");
93 filename = savestring ((*cmd), end - (*cmd));
94 make_cleanup (xfree, filename);
95 (*cmd) = skip_spaces (end);
97 gdb_assert (filename != NULL);
99 fullname = tilde_expand (filename);
100 make_cleanup (xfree, fullname);
106 fopen_with_cleanup (const char *filename, const char *mode)
108 FILE *file = fopen (filename, mode);
110 perror_with_name (filename);
111 make_cleanup_fclose (file);
116 bfd_openr_with_cleanup (const char *filename, const char *target)
120 ibfd = bfd_openr (filename, target);
122 error (_("Failed to open %s: %s."), filename,
123 bfd_errmsg (bfd_get_error ()));
125 make_cleanup_bfd_close (ibfd);
126 if (!bfd_check_format (ibfd, bfd_object))
127 error (_("'%s' is not a recognized file format."), filename);
133 bfd_openw_with_cleanup (const char *filename, const char *target,
138 if (*mode == 'w') /* Write: create new file */
140 obfd = bfd_openw (filename, target);
142 error (_("Failed to open %s: %s."), filename,
143 bfd_errmsg (bfd_get_error ()));
144 make_cleanup_bfd_close (obfd);
145 if (!bfd_set_format (obfd, bfd_object))
146 error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
148 else if (*mode == 'a') /* Append to existing file */
149 { /* FIXME -- doesn't work... */
150 error (_("bfd_openw does not work with append."));
153 error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
158 struct cmd_list_element *dump_cmdlist;
159 struct cmd_list_element *append_cmdlist;
160 struct cmd_list_element *srec_cmdlist;
161 struct cmd_list_element *ihex_cmdlist;
162 struct cmd_list_element *tekhex_cmdlist;
163 struct cmd_list_element *binary_dump_cmdlist;
164 struct cmd_list_element *binary_append_cmdlist;
167 dump_command (char *cmd, int from_tty)
169 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
170 help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
174 append_command (char *cmd, int from_tty)
176 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
177 help_list (dump_cmdlist, "append ", -1, gdb_stdout);
181 dump_binary_file (const char *filename, const char *mode,
182 const bfd_byte *buf, int len)
187 file = fopen_with_cleanup (filename, mode);
188 status = fwrite (buf, len, 1, file);
190 perror_with_name (filename);
194 dump_bfd_file (const char *filename, const char *mode,
195 const char *target, CORE_ADDR vaddr,
196 const bfd_byte *buf, int len)
201 obfd = bfd_openw_with_cleanup (filename, target, mode);
202 osection = bfd_make_section_anyway (obfd, ".newsec");
203 bfd_set_section_size (obfd, osection, len);
204 bfd_set_section_vma (obfd, osection, vaddr);
205 bfd_set_section_alignment (obfd, osection, 0);
206 bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
209 osection->entsize = 0;
210 bfd_set_section_contents (obfd, osection, buf, 0, len);
214 dump_memory_to_file (char *cmd, char *mode, char *file_format)
216 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
227 filename = scan_filename_with_cleanup (&cmd, NULL);
229 /* Find the low address. */
230 if (cmd == NULL || *cmd == '\0')
231 error (_("Missing start address."));
232 lo_exp = scan_expression_with_cleanup (&cmd, NULL);
234 /* Find the second address - rest of line. */
235 if (cmd == NULL || *cmd == '\0')
236 error (_("Missing stop address."));
239 lo = parse_and_eval_address (lo_exp);
240 hi = parse_and_eval_address (hi_exp);
242 error (_("Invalid memory address range (start >= end)."));
245 /* FIXME: Should use read_memory_partial() and a magic blocking
247 buf = xmalloc (count);
248 make_cleanup (xfree, buf);
249 target_read_memory (lo, buf, count);
251 /* Have everything. Open/write the data. */
252 if (file_format == NULL || strcmp (file_format, "binary") == 0)
254 dump_binary_file (filename, mode, buf, count);
258 dump_bfd_file (filename, mode, file_format, lo, buf, count);
261 do_cleanups (old_cleanups);
265 dump_memory_command (char *cmd, char *mode)
267 dump_memory_to_file (cmd, mode, "binary");
271 dump_value_to_file (char *cmd, char *mode, char *file_format)
273 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
278 filename = scan_filename_with_cleanup (&cmd, NULL);
280 /* Find the value. */
281 if (cmd == NULL || *cmd == '\0')
282 error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
283 val = parse_and_eval (cmd);
285 error (_("Invalid expression."));
287 /* Have everything. Open/write the data. */
288 if (file_format == NULL || strcmp (file_format, "binary") == 0)
290 dump_binary_file (filename, mode, value_contents (val),
291 TYPE_LENGTH (value_type (val)));
297 if (VALUE_LVAL (val))
299 vaddr = value_address (val);
304 warning (_("value is not an lval: address assumed to be zero"));
307 dump_bfd_file (filename, mode, file_format, vaddr,
308 value_contents (val),
309 TYPE_LENGTH (value_type (val)));
312 do_cleanups (old_cleanups);
316 dump_value_command (char *cmd, char *mode)
318 dump_value_to_file (cmd, mode, "binary");
322 dump_srec_memory (char *args, int from_tty)
324 dump_memory_to_file (args, FOPEN_WB, "srec");
328 dump_srec_value (char *args, int from_tty)
330 dump_value_to_file (args, FOPEN_WB, "srec");
334 dump_ihex_memory (char *args, int from_tty)
336 dump_memory_to_file (args, FOPEN_WB, "ihex");
340 dump_ihex_value (char *args, int from_tty)
342 dump_value_to_file (args, FOPEN_WB, "ihex");
346 dump_tekhex_memory (char *args, int from_tty)
348 dump_memory_to_file (args, FOPEN_WB, "tekhex");
352 dump_tekhex_value (char *args, int from_tty)
354 dump_value_to_file (args, FOPEN_WB, "tekhex");
358 dump_binary_memory (char *args, int from_tty)
360 dump_memory_to_file (args, FOPEN_WB, "binary");
364 dump_binary_value (char *args, int from_tty)
366 dump_value_to_file (args, FOPEN_WB, "binary");
370 append_binary_memory (char *args, int from_tty)
372 dump_memory_to_file (args, FOPEN_AB, "binary");
376 append_binary_value (char *args, int from_tty)
378 dump_value_to_file (args, FOPEN_AB, "binary");
383 void (*func) (char *cmd, char *mode);
388 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
390 struct dump_context *d = get_cmd_context (c);
391 d->func (args, d->mode);
395 add_dump_command (char *name, void (*func) (char *args, char *mode),
399 struct cmd_list_element *c;
400 struct dump_context *d;
402 c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
403 c->completer = filename_completer;
404 d = XMALLOC (struct dump_context);
407 set_cmd_context (c, d);
408 c->func = call_dump_func;
410 c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
411 c->completer = filename_completer;
412 d = XMALLOC (struct dump_context);
415 set_cmd_context (c, d);
416 c->func = call_dump_func;
418 /* Replace "Dump " at start of docstring with "Append " (borrowed
419 from [deleted] deprecated_add_show_from_set). */
420 if ( c->doc[0] == 'W'
426 c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
429 /* Opaque data for restore_section_callback. */
430 struct callback_data {
432 CORE_ADDR load_start;
436 /* Function: restore_section_callback.
438 Callback function for bfd_map_over_sections.
439 Selectively loads the sections into memory. */
442 restore_section_callback (bfd *ibfd, asection *isec, void *args)
444 struct callback_data *data = args;
445 bfd_vma sec_start = bfd_section_vma (ibfd, isec);
446 bfd_size_type size = bfd_section_size (ibfd, isec);
447 bfd_vma sec_end = sec_start + size;
448 bfd_size_type sec_offset = 0;
449 bfd_size_type sec_load_count = size;
450 struct cleanup *old_chain;
454 /* Ignore non-loadable sections, eg. from elf files. */
455 if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
458 /* Does the section overlap with the desired restore range? */
459 if (sec_end <= data->load_start
460 || (data->load_end > 0 && sec_start >= data->load_end))
462 /* No, no useable data in this section. */
463 printf_filtered (_("skipping section %s...\n"),
464 bfd_section_name (ibfd, isec));
468 /* Compare section address range with user-requested
469 address range (if any). Compute where the actual
470 transfer should start and end. */
471 if (sec_start < data->load_start)
472 sec_offset = data->load_start - sec_start;
473 /* Size of a partial transfer: */
474 sec_load_count -= sec_offset;
475 if (data->load_end > 0 && sec_end > data->load_end)
476 sec_load_count -= sec_end - data->load_end;
479 buf = xmalloc (size);
480 old_chain = make_cleanup (xfree, buf);
481 if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
482 error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
483 bfd_errmsg (bfd_get_error ()));
485 printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
486 bfd_section_name (ibfd, isec),
487 (unsigned long) sec_start,
488 (unsigned long) sec_end);
490 if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
491 printf_filtered (" into memory (0x%s to 0x%s)\n",
492 paddr_nz ((unsigned long) sec_start
493 + sec_offset + data->load_offset),
494 paddr_nz ((unsigned long) sec_start + sec_offset
495 + data->load_offset + sec_load_count));
497 puts_filtered ("\n");
499 /* Write the data. */
500 ret = target_write_memory (sec_start + sec_offset + data->load_offset,
501 buf + sec_offset, sec_load_count);
503 warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
504 do_cleanups (old_chain);
509 restore_binary_file (char *filename, struct callback_data *data)
511 FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
516 /* Get the file size for reading. */
517 if (fseek (file, 0, SEEK_END) == 0)
520 perror_with_name (filename);
522 if (len <= data->load_start)
523 error (_("Start address is greater than length of binary file %s."),
526 /* Chop off "len" if it exceeds the requested load_end addr. */
527 if (data->load_end != 0 && data->load_end < len)
528 len = data->load_end;
529 /* Chop off "len" if the requested load_start addr skips some bytes. */
530 if (data->load_start > 0)
531 len -= data->load_start;
534 ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
536 (unsigned long) data->load_start + data->load_offset,
537 (unsigned long) data->load_start + data->load_offset + len);
539 /* Now set the file pos to the requested load start pos. */
540 if (fseek (file, data->load_start, SEEK_SET) != 0)
541 perror_with_name (filename);
543 /* Now allocate a buffer and read the file contents. */
545 make_cleanup (xfree, buf);
546 if (fread (buf, 1, len, file) != len)
547 perror_with_name (filename);
549 /* Now write the buffer into target memory. */
550 len = target_write_memory (data->load_start + data->load_offset, buf, len);
552 warning (_("restore: memory write failed (%s)."), safe_strerror (len));
557 restore_command (char *args, int from_tty)
560 struct callback_data data;
564 if (!target_has_execution)
567 data.load_offset = 0;
571 /* Parse the input arguments. First is filename (required). */
572 filename = scan_filename_with_cleanup (&args, NULL);
573 if (args != NULL && *args != '\0')
575 char *binary_string = "binary";
577 /* Look for optional "binary" flag. */
578 if (strncmp (args, binary_string, strlen (binary_string)) == 0)
581 args += strlen (binary_string);
582 args = skip_spaces (args);
584 /* Parse offset (optional). */
585 if (args != NULL && *args != '\0')
587 parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
588 if (args != NULL && *args != '\0')
590 /* Parse start address (optional). */
592 parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
593 if (args != NULL && *args != '\0')
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."));
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);
611 restore_binary_file (filename, &data);
615 /* Open the file for loading. */
616 ibfd = bfd_openr_with_cleanup (filename, NULL);
618 /* Process the sections. */
619 bfd_map_over_sections (ibfd, restore_section_callback, &data);
625 srec_dump_command (char *cmd, int from_tty)
627 printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
628 help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
632 ihex_dump_command (char *cmd, int from_tty)
634 printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
635 help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
639 tekhex_dump_command (char *cmd, int from_tty)
641 printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
642 help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
646 binary_dump_command (char *cmd, int from_tty)
648 printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
649 help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
653 binary_append_command (char *cmd, int from_tty)
655 printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
656 help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
659 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
662 _initialize_cli_dump (void)
664 struct cmd_list_element *c;
665 add_prefix_cmd ("dump", class_vars, dump_command, _("\
666 Dump target code/data to a local file."),
667 &dump_cmdlist, "dump ",
670 add_prefix_cmd ("append", class_vars, append_command, _("\
671 Append target code/data to a local file."),
672 &append_cmdlist, "append ",
676 add_dump_command ("memory", dump_memory_command, "\
677 Write contents of memory to a raw binary file.\n\
678 Arguments are FILE START STOP. Writes the contents of memory within the\n\
679 range [START .. STOP) to the specifed FILE in raw target ordered bytes.");
681 add_dump_command ("value", dump_value_command, "\
682 Write the value of an expression to a raw binary file.\n\
683 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
684 the specified FILE in raw target ordered bytes.");
686 add_prefix_cmd ("srec", all_commands, srec_dump_command, _("\
687 Write target code/data to an srec file."),
688 &srec_cmdlist, "dump srec ",
692 add_prefix_cmd ("ihex", all_commands, ihex_dump_command, _("\
693 Write target code/data to an intel hex file."),
694 &ihex_cmdlist, "dump ihex ",
698 add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command, _("\
699 Write target code/data to a tekhex file."),
700 &tekhex_cmdlist, "dump tekhex ",
704 add_prefix_cmd ("binary", all_commands, binary_dump_command, _("\
705 Write target code/data to a raw binary file."),
706 &binary_dump_cmdlist, "dump binary ",
710 add_prefix_cmd ("binary", all_commands, binary_append_command, _("\
711 Append target code/data to a raw binary file."),
712 &binary_append_cmdlist, "append binary ",
716 add_cmd ("memory", all_commands, dump_srec_memory, _("\
717 Write contents of memory to an srec file.\n\
718 Arguments are FILE START STOP. Writes the contents of memory\n\
719 within the range [START .. STOP) to the specifed FILE in srec format."),
722 add_cmd ("value", all_commands, dump_srec_value, _("\
723 Write the value of an expression to an srec file.\n\
724 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
725 to the specified FILE in srec format."),
728 add_cmd ("memory", all_commands, dump_ihex_memory, _("\
729 Write contents of memory to an ihex file.\n\
730 Arguments are FILE START STOP. Writes the contents of memory within\n\
731 the range [START .. STOP) to the specifed FILE in intel hex format."),
734 add_cmd ("value", all_commands, dump_ihex_value, _("\
735 Write the value of an expression to an ihex file.\n\
736 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
737 to the specified FILE in intel hex format."),
740 add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
741 Write contents of memory to a tekhex file.\n\
742 Arguments are FILE START STOP. Writes the contents of memory\n\
743 within the range [START .. STOP) to the specifed FILE in tekhex format."),
746 add_cmd ("value", all_commands, dump_tekhex_value, _("\
747 Write the value of an expression to a tekhex file.\n\
748 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
749 to the specified FILE in tekhex format."),
752 add_cmd ("memory", all_commands, dump_binary_memory, _("\
753 Write contents of memory to a raw binary file.\n\
754 Arguments are FILE START STOP. Writes the contents of memory\n\
755 within the range [START .. STOP) to the specifed FILE in binary format."),
756 &binary_dump_cmdlist);
758 add_cmd ("value", all_commands, dump_binary_value, _("\
759 Write the value of an expression to a raw binary file.\n\
760 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
761 to the specified FILE in raw target ordered bytes."),
762 &binary_dump_cmdlist);
764 add_cmd ("memory", all_commands, append_binary_memory, _("\
765 Append contents of memory to a raw binary file.\n\
766 Arguments are FILE START STOP. Writes the contents of memory within the\n\
767 range [START .. STOP) to the specifed FILE in raw target ordered bytes."),
768 &binary_append_cmdlist);
770 add_cmd ("value", all_commands, append_binary_value, _("\
771 Append the value of an expression to a raw binary file.\n\
772 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
773 to the specified FILE in raw target ordered bytes."),
774 &binary_append_cmdlist);
776 c = add_com ("restore", class_vars, restore_command, _("\
777 Restore the contents of FILE to target memory.\n\
778 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
779 OFFSET will be added to the base address of the file (default zero).\n\
780 If START and END are given, only the file contents within that range\n\
781 (file relative) will be restored to target memory."));
782 c->completer = filename_completer;
783 /* FIXME: completers for other commands. */