1 /* Dump-to-file commands, for GDB, the GNU debugger.
3 Copyright (c) 2002, 2005, 2007-2012 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 #include "cli/cli-utils.h"
36 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
40 scan_expression_with_cleanup (char **cmd, const char *def)
42 if ((*cmd) == NULL || (**cmd) == '\0')
44 char *exp = xstrdup (def);
46 make_cleanup (xfree, exp);
54 end = (*cmd) + strcspn (*cmd, " \t");
55 exp = savestring ((*cmd), end - (*cmd));
56 make_cleanup (xfree, exp);
57 (*cmd) = skip_spaces (end);
64 scan_filename_with_cleanup (char **cmd, const char *defname)
69 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
75 error (_("Missing filename."));
76 filename = xstrdup (defname);
77 make_cleanup (xfree, filename);
81 /* FIXME: should parse a possibly quoted string. */
84 (*cmd) = skip_spaces (*cmd);
85 end = *cmd + strcspn (*cmd, " \t");
86 filename = savestring ((*cmd), end - (*cmd));
87 make_cleanup (xfree, filename);
88 (*cmd) = skip_spaces (end);
90 gdb_assert (filename != NULL);
92 fullname = tilde_expand (filename);
93 make_cleanup (xfree, fullname);
99 fopen_with_cleanup (const char *filename, const char *mode)
101 FILE *file = fopen (filename, mode);
104 perror_with_name (filename);
105 make_cleanup_fclose (file);
110 bfd_openr_with_cleanup (const char *filename, const char *target)
114 ibfd = bfd_openr (filename, target);
116 error (_("Failed to open %s: %s."), filename,
117 bfd_errmsg (bfd_get_error ()));
119 make_cleanup_bfd_close (ibfd);
120 if (!bfd_check_format (ibfd, bfd_object))
121 error (_("'%s' is not a recognized file format."), filename);
127 bfd_openw_with_cleanup (const char *filename, const char *target,
132 if (*mode == 'w') /* Write: create new file */
134 obfd = bfd_openw (filename, target);
136 error (_("Failed to open %s: %s."), filename,
137 bfd_errmsg (bfd_get_error ()));
138 make_cleanup_bfd_close (obfd);
139 if (!bfd_set_format (obfd, bfd_object))
140 error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
142 else if (*mode == 'a') /* Append to existing file. */
143 { /* FIXME -- doesn't work... */
144 error (_("bfd_openw does not work with append."));
147 error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
152 struct cmd_list_element *dump_cmdlist;
153 struct cmd_list_element *append_cmdlist;
154 struct cmd_list_element *srec_cmdlist;
155 struct cmd_list_element *ihex_cmdlist;
156 struct cmd_list_element *tekhex_cmdlist;
157 struct cmd_list_element *binary_dump_cmdlist;
158 struct cmd_list_element *binary_append_cmdlist;
161 dump_command (char *cmd, int from_tty)
163 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
164 help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
168 append_command (char *cmd, int from_tty)
170 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
171 help_list (dump_cmdlist, "append ", -1, gdb_stdout);
175 dump_binary_file (const char *filename, const char *mode,
176 const bfd_byte *buf, ULONGEST len)
181 file = fopen_with_cleanup (filename, mode);
182 status = fwrite (buf, len, 1, file);
184 perror_with_name (filename);
188 dump_bfd_file (const char *filename, const char *mode,
189 const char *target, CORE_ADDR vaddr,
190 const bfd_byte *buf, ULONGEST len)
195 obfd = bfd_openw_with_cleanup (filename, target, mode);
196 osection = bfd_make_section_anyway (obfd, ".newsec");
197 bfd_set_section_size (obfd, osection, len);
198 bfd_set_section_vma (obfd, osection, vaddr);
199 bfd_set_section_alignment (obfd, osection, 0);
200 bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
203 osection->entsize = 0;
204 if (!bfd_set_section_contents (obfd, osection, buf, 0, len))
205 warning (_("writing dump file '%s' (%s)"), filename,
206 bfd_errmsg (bfd_get_error ()));
210 dump_memory_to_file (char *cmd, char *mode, char *file_format)
212 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
222 filename = scan_filename_with_cleanup (&cmd, NULL);
224 /* Find the low address. */
225 if (cmd == NULL || *cmd == '\0')
226 error (_("Missing start address."));
227 lo_exp = scan_expression_with_cleanup (&cmd, NULL);
229 /* Find the second address - rest of line. */
230 if (cmd == NULL || *cmd == '\0')
231 error (_("Missing stop address."));
234 lo = parse_and_eval_address (lo_exp);
235 hi = parse_and_eval_address (hi_exp);
237 error (_("Invalid memory address range (start >= end)."));
240 /* FIXME: Should use read_memory_partial() and a magic blocking
242 buf = xmalloc (count);
243 make_cleanup (xfree, buf);
244 read_memory (lo, buf, count);
246 /* Have everything. Open/write the data. */
247 if (file_format == NULL || strcmp (file_format, "binary") == 0)
249 dump_binary_file (filename, mode, buf, count);
253 dump_bfd_file (filename, mode, file_format, lo, buf, count);
256 do_cleanups (old_cleanups);
260 dump_memory_command (char *cmd, char *mode)
262 dump_memory_to_file (cmd, mode, "binary");
266 dump_value_to_file (char *cmd, char *mode, char *file_format)
268 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
273 filename = scan_filename_with_cleanup (&cmd, NULL);
275 /* Find the value. */
276 if (cmd == NULL || *cmd == '\0')
277 error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
278 val = parse_and_eval (cmd);
280 error (_("Invalid expression."));
282 /* Have everything. Open/write the data. */
283 if (file_format == NULL || strcmp (file_format, "binary") == 0)
285 dump_binary_file (filename, mode, value_contents (val),
286 TYPE_LENGTH (value_type (val)));
292 if (VALUE_LVAL (val))
294 vaddr = value_address (val);
299 warning (_("value is not an lval: address assumed to be zero"));
302 dump_bfd_file (filename, mode, file_format, vaddr,
303 value_contents (val),
304 TYPE_LENGTH (value_type (val)));
307 do_cleanups (old_cleanups);
311 dump_value_command (char *cmd, char *mode)
313 dump_value_to_file (cmd, mode, "binary");
317 dump_srec_memory (char *args, int from_tty)
319 dump_memory_to_file (args, FOPEN_WB, "srec");
323 dump_srec_value (char *args, int from_tty)
325 dump_value_to_file (args, FOPEN_WB, "srec");
329 dump_ihex_memory (char *args, int from_tty)
331 dump_memory_to_file (args, FOPEN_WB, "ihex");
335 dump_ihex_value (char *args, int from_tty)
337 dump_value_to_file (args, FOPEN_WB, "ihex");
341 dump_tekhex_memory (char *args, int from_tty)
343 dump_memory_to_file (args, FOPEN_WB, "tekhex");
347 dump_tekhex_value (char *args, int from_tty)
349 dump_value_to_file (args, FOPEN_WB, "tekhex");
353 dump_binary_memory (char *args, int from_tty)
355 dump_memory_to_file (args, FOPEN_WB, "binary");
359 dump_binary_value (char *args, int from_tty)
361 dump_value_to_file (args, FOPEN_WB, "binary");
365 append_binary_memory (char *args, int from_tty)
367 dump_memory_to_file (args, FOPEN_AB, "binary");
371 append_binary_value (char *args, int from_tty)
373 dump_value_to_file (args, FOPEN_AB, "binary");
378 void (*func) (char *cmd, char *mode);
383 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
385 struct dump_context *d = get_cmd_context (c);
387 d->func (args, d->mode);
391 add_dump_command (char *name, void (*func) (char *args, char *mode),
395 struct cmd_list_element *c;
396 struct dump_context *d;
398 c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
399 c->completer = filename_completer;
400 d = XMALLOC (struct dump_context);
403 set_cmd_context (c, d);
404 c->func = call_dump_func;
406 c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
407 c->completer = filename_completer;
408 d = XMALLOC (struct dump_context);
411 set_cmd_context (c, d);
412 c->func = call_dump_func;
414 /* Replace "Dump " at start of docstring with "Append " (borrowed
415 from [deleted] deprecated_add_show_from_set). */
416 if ( c->doc[0] == 'W'
422 c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
425 /* Opaque data for restore_section_callback. */
426 struct callback_data {
427 CORE_ADDR load_offset;
428 CORE_ADDR load_start;
432 /* Function: restore_section_callback.
434 Callback function for bfd_map_over_sections.
435 Selectively loads the sections into memory. */
438 restore_section_callback (bfd *ibfd, asection *isec, void *args)
440 struct callback_data *data = args;
441 bfd_vma sec_start = bfd_section_vma (ibfd, isec);
442 bfd_size_type size = bfd_section_size (ibfd, isec);
443 bfd_vma sec_end = sec_start + size;
444 bfd_size_type sec_offset = 0;
445 bfd_size_type sec_load_count = size;
446 struct cleanup *old_chain;
450 /* Ignore non-loadable sections, eg. from elf files. */
451 if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
454 /* Does the section overlap with the desired restore range? */
455 if (sec_end <= data->load_start
456 || (data->load_end > 0 && sec_start >= data->load_end))
458 /* No, no useable data in this section. */
459 printf_filtered (_("skipping section %s...\n"),
460 bfd_section_name (ibfd, isec));
464 /* Compare section address range with user-requested
465 address range (if any). Compute where the actual
466 transfer should start and end. */
467 if (sec_start < data->load_start)
468 sec_offset = data->load_start - sec_start;
469 /* Size of a partial transfer. */
470 sec_load_count -= sec_offset;
471 if (data->load_end > 0 && sec_end > data->load_end)
472 sec_load_count -= sec_end - data->load_end;
475 buf = xmalloc (size);
476 old_chain = make_cleanup (xfree, buf);
477 if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
478 error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
479 bfd_errmsg (bfd_get_error ()));
481 printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
482 bfd_section_name (ibfd, isec),
483 (unsigned long) sec_start,
484 (unsigned long) sec_end);
486 if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
487 printf_filtered (" into memory (%s to %s)\n",
488 paddress (target_gdbarch,
489 (unsigned long) sec_start
490 + sec_offset + data->load_offset),
491 paddress (target_gdbarch,
492 (unsigned long) sec_start + sec_offset
493 + data->load_offset + sec_load_count));
495 puts_filtered ("\n");
497 /* Write the data. */
498 ret = target_write_memory (sec_start + sec_offset + data->load_offset,
499 buf + sec_offset, sec_load_count);
501 warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
502 do_cleanups (old_chain);
507 restore_binary_file (char *filename, struct callback_data *data)
509 FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
513 /* Get the file size for reading. */
514 if (fseek (file, 0, SEEK_END) == 0)
518 perror_with_name (filename);
521 perror_with_name (filename);
523 if (len <= data->load_start)
524 error (_("Start address is greater than length of binary file %s."),
527 /* Chop off "len" if it exceeds the requested load_end addr. */
528 if (data->load_end != 0 && data->load_end < len)
529 len = data->load_end;
530 /* Chop off "len" if the requested load_start addr skips some bytes. */
531 if (data->load_start > 0)
532 len -= data->load_start;
535 ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
537 (unsigned long) (data->load_start + data->load_offset),
538 (unsigned long) (data->load_start + data->load_offset + len));
540 /* Now set the file pos to the requested load start pos. */
541 if (fseek (file, data->load_start, SEEK_SET) != 0)
542 perror_with_name (filename);
544 /* Now allocate a buffer and read the file contents. */
546 make_cleanup (xfree, buf);
547 if (fread (buf, 1, len, file) != len)
548 perror_with_name (filename);
550 /* Now write the buffer into target memory. */
551 len = target_write_memory (data->load_start + data->load_offset, buf, len);
553 warning (_("restore: memory write failed (%s)."), safe_strerror (len));
558 restore_command (char *args, int from_tty)
561 struct callback_data data;
565 if (!target_has_execution)
568 data.load_offset = 0;
572 /* Parse the input arguments. First is filename (required). */
573 filename = scan_filename_with_cleanup (&args, NULL);
574 if (args != NULL && *args != '\0')
576 char *binary_string = "binary";
578 /* Look for optional "binary" flag. */
579 if (strncmp (args, binary_string, strlen (binary_string)) == 0)
582 args += strlen (binary_string);
583 args = skip_spaces (args);
585 /* Parse offset (optional). */
586 if (args != NULL && *args != '\0')
588 parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
589 if (args != NULL && *args != '\0')
591 /* Parse start address (optional). */
593 parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
594 if (args != NULL && *args != '\0')
596 /* Parse end address (optional). */
597 data.load_end = parse_and_eval_long (args);
598 if (data.load_end <= data.load_start)
599 error (_("Start must be less than end."));
605 printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
606 filename, (unsigned long) data.load_offset,
607 (unsigned long) data.load_start,
608 (unsigned long) data.load_end);
612 restore_binary_file (filename, &data);
616 /* Open the file for loading. */
617 ibfd = bfd_openr_with_cleanup (filename, NULL);
619 /* Process the sections. */
620 bfd_map_over_sections (ibfd, restore_section_callback, &data);
626 srec_dump_command (char *cmd, int from_tty)
628 printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
629 help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
633 ihex_dump_command (char *cmd, int from_tty)
635 printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
636 help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
640 tekhex_dump_command (char *cmd, int from_tty)
642 printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
643 help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
647 binary_dump_command (char *cmd, int from_tty)
649 printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
650 help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
654 binary_append_command (char *cmd, int from_tty)
656 printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
657 help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
660 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
663 _initialize_cli_dump (void)
665 struct cmd_list_element *c;
667 add_prefix_cmd ("dump", class_vars, dump_command,
668 _("Dump target code/data to a local file."),
669 &dump_cmdlist, "dump ",
672 add_prefix_cmd ("append", class_vars, append_command,
673 _("Append target code/data to a local file."),
674 &append_cmdlist, "append ",
678 add_dump_command ("memory", dump_memory_command, "\
679 Write contents of memory to a raw binary file.\n\
680 Arguments are FILE START STOP. Writes the contents of memory within the\n\
681 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
683 add_dump_command ("value", dump_value_command, "\
684 Write the value of an expression to a raw binary file.\n\
685 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
686 the specified FILE in raw target ordered bytes.");
688 add_prefix_cmd ("srec", all_commands, srec_dump_command,
689 _("Write target code/data to an srec file."),
690 &srec_cmdlist, "dump srec ",
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 ",
700 add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command,
701 _("Write target code/data to a tekhex file."),
702 &tekhex_cmdlist, "dump tekhex ",
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 ",
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 ",
718 add_cmd ("memory", all_commands, dump_srec_memory, _("\
719 Write contents of memory to an srec file.\n\
720 Arguments are FILE START STOP. Writes the contents of memory\n\
721 within the range [START .. STOP) to the specified FILE in srec format."),
724 add_cmd ("value", all_commands, dump_srec_value, _("\
725 Write the value of an expression to an srec file.\n\
726 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
727 to the specified FILE in srec format."),
730 add_cmd ("memory", all_commands, dump_ihex_memory, _("\
731 Write contents of memory to an ihex file.\n\
732 Arguments are FILE START STOP. Writes the contents of memory within\n\
733 the range [START .. STOP) to the specified FILE in intel hex format."),
736 add_cmd ("value", all_commands, dump_ihex_value, _("\
737 Write the value of an expression to an ihex file.\n\
738 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
739 to the specified FILE in intel hex format."),
742 add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
743 Write contents of memory to a tekhex file.\n\
744 Arguments are FILE START STOP. Writes the contents of memory\n\
745 within the range [START .. STOP) to the specified FILE in tekhex format."),
748 add_cmd ("value", all_commands, dump_tekhex_value, _("\
749 Write the value of an expression to a tekhex file.\n\
750 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
751 to the specified FILE in tekhex format."),
754 add_cmd ("memory", all_commands, dump_binary_memory, _("\
755 Write contents of memory to a raw binary file.\n\
756 Arguments are FILE START STOP. Writes the contents of memory\n\
757 within the range [START .. STOP) to the specified FILE in binary format."),
758 &binary_dump_cmdlist);
760 add_cmd ("value", all_commands, dump_binary_value, _("\
761 Write the value of an expression to a raw binary file.\n\
762 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
763 to the specified FILE in raw target ordered bytes."),
764 &binary_dump_cmdlist);
766 add_cmd ("memory", all_commands, append_binary_memory, _("\
767 Append contents of memory to a raw binary file.\n\
768 Arguments are FILE START STOP. Writes the contents of memory within the\n\
769 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
770 &binary_append_cmdlist);
772 add_cmd ("value", all_commands, append_binary_value, _("\
773 Append the value of an expression to a raw binary file.\n\
774 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
775 to the specified FILE in raw target ordered bytes."),
776 &binary_append_cmdlist);
778 c = add_com ("restore", class_vars, restore_command, _("\
779 Restore the contents of FILE to target memory.\n\
780 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
781 OFFSET will be added to the base address of the file (default zero).\n\
782 If 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. */