1 /* Dump-to-file commands, for GDB, the GNU debugger.
3 Copyright (C) 2002-2014 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 "cli/cli-decode.h"
24 #include "cli/cli-cmds.h"
26 #include "completer.h"
29 #include "readline/readline.h"
31 #include "cli/cli-utils.h"
33 #include "filestuff.h"
37 scan_expression_with_cleanup (const char **cmd, const char *def)
39 if ((*cmd) == NULL || (**cmd) == '\0')
41 char *exp = xstrdup (def);
43 make_cleanup (xfree, exp);
51 end = (*cmd) + strcspn (*cmd, " \t");
52 exp = savestring ((*cmd), end - (*cmd));
53 make_cleanup (xfree, exp);
54 (*cmd) = skip_spaces_const (end);
61 scan_filename_with_cleanup (const char **cmd, const char *defname)
66 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
72 error (_("Missing filename."));
73 filename = xstrdup (defname);
74 make_cleanup (xfree, filename);
78 /* FIXME: should parse a possibly quoted string. */
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);
87 gdb_assert (filename != NULL);
89 fullname = tilde_expand (filename);
90 make_cleanup (xfree, fullname);
96 fopen_with_cleanup (const char *filename, const char *mode)
98 FILE *file = gdb_fopen_cloexec (filename, mode);
101 perror_with_name (filename);
102 make_cleanup_fclose (file);
107 bfd_openr_with_cleanup (const char *filename, const char *target)
111 ibfd = gdb_bfd_openr (filename, target);
113 error (_("Failed to open %s: %s."), filename,
114 bfd_errmsg (bfd_get_error ()));
116 make_cleanup_bfd_unref (ibfd);
117 if (!bfd_check_format (ibfd, bfd_object))
118 error (_("'%s' is not a recognized file format."), filename);
124 bfd_openw_with_cleanup (const char *filename, const char *target,
129 if (*mode == 'w') /* Write: create new file */
131 obfd = gdb_bfd_openw (filename, target);
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 ()));
139 else if (*mode == 'a') /* Append to existing file. */
140 { /* FIXME -- doesn't work... */
141 error (_("bfd_openw does not work with append."));
144 error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
149 static struct cmd_list_element *dump_cmdlist;
150 static struct cmd_list_element *append_cmdlist;
151 static struct cmd_list_element *srec_cmdlist;
152 static struct cmd_list_element *ihex_cmdlist;
153 static struct cmd_list_element *tekhex_cmdlist;
154 static struct cmd_list_element *binary_dump_cmdlist;
155 static struct cmd_list_element *binary_append_cmdlist;
158 dump_command (char *cmd, int from_tty)
160 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
161 help_list (dump_cmdlist, "dump ", all_commands, gdb_stdout);
165 append_command (char *cmd, int from_tty)
167 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
168 help_list (dump_cmdlist, "append ", all_commands, gdb_stdout);
172 dump_binary_file (const char *filename, const char *mode,
173 const bfd_byte *buf, ULONGEST len)
178 file = fopen_with_cleanup (filename, mode);
179 status = fwrite (buf, len, 1, file);
181 perror_with_name (filename);
185 dump_bfd_file (const char *filename, const char *mode,
186 const char *target, CORE_ADDR vaddr,
187 const bfd_byte *buf, ULONGEST len)
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
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 ()));
207 dump_memory_to_file (const char *cmd, const char *mode, const char *file_format)
209 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
213 const char *filename;
219 filename = scan_filename_with_cleanup (&cmd, NULL);
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);
226 /* Find the second address - rest of line. */
227 if (cmd == NULL || *cmd == '\0')
228 error (_("Missing stop address."));
231 lo = parse_and_eval_address (lo_exp);
232 hi = parse_and_eval_address (hi_exp);
234 error (_("Invalid memory address range (start >= end)."));
237 /* FIXME: Should use read_memory_partial() and a magic blocking
239 buf = xmalloc (count);
240 make_cleanup (xfree, buf);
241 read_memory (lo, buf, count);
243 /* Have everything. Open/write the data. */
244 if (file_format == NULL || strcmp (file_format, "binary") == 0)
246 dump_binary_file (filename, mode, buf, count);
250 dump_bfd_file (filename, mode, file_format, lo, buf, count);
253 do_cleanups (old_cleanups);
257 dump_memory_command (char *cmd, char *mode)
259 dump_memory_to_file (cmd, mode, "binary");
263 dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
265 struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
267 const char *filename;
270 filename = scan_filename_with_cleanup (&cmd, NULL);
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);
277 error (_("Invalid expression."));
279 /* Have everything. Open/write the data. */
280 if (file_format == NULL || strcmp (file_format, "binary") == 0)
282 dump_binary_file (filename, mode, value_contents (val),
283 TYPE_LENGTH (value_type (val)));
289 if (VALUE_LVAL (val))
291 vaddr = value_address (val);
296 warning (_("value is not an lval: address assumed to be zero"));
299 dump_bfd_file (filename, mode, file_format, vaddr,
300 value_contents (val),
301 TYPE_LENGTH (value_type (val)));
304 do_cleanups (old_cleanups);
308 dump_value_command (char *cmd, char *mode)
310 dump_value_to_file (cmd, mode, "binary");
314 dump_srec_memory (char *args, int from_tty)
316 dump_memory_to_file (args, FOPEN_WB, "srec");
320 dump_srec_value (char *args, int from_tty)
322 dump_value_to_file (args, FOPEN_WB, "srec");
326 dump_ihex_memory (char *args, int from_tty)
328 dump_memory_to_file (args, FOPEN_WB, "ihex");
332 dump_ihex_value (char *args, int from_tty)
334 dump_value_to_file (args, FOPEN_WB, "ihex");
338 dump_tekhex_memory (char *args, int from_tty)
340 dump_memory_to_file (args, FOPEN_WB, "tekhex");
344 dump_tekhex_value (char *args, int from_tty)
346 dump_value_to_file (args, FOPEN_WB, "tekhex");
350 dump_binary_memory (char *args, int from_tty)
352 dump_memory_to_file (args, FOPEN_WB, "binary");
356 dump_binary_value (char *args, int from_tty)
358 dump_value_to_file (args, FOPEN_WB, "binary");
362 append_binary_memory (char *args, int from_tty)
364 dump_memory_to_file (args, FOPEN_AB, "binary");
368 append_binary_value (char *args, int from_tty)
370 dump_value_to_file (args, FOPEN_AB, "binary");
375 void (*func) (char *cmd, char *mode);
380 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
382 struct dump_context *d = get_cmd_context (c);
384 d->func (args, d->mode);
388 add_dump_command (char *name, void (*func) (char *args, char *mode),
392 struct cmd_list_element *c;
393 struct dump_context *d;
395 c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
396 c->completer = filename_completer;
397 d = XNEW (struct dump_context);
400 set_cmd_context (c, d);
401 c->func = call_dump_func;
403 c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
404 c->completer = filename_completer;
405 d = XNEW (struct dump_context);
408 set_cmd_context (c, d);
409 c->func = call_dump_func;
411 /* Replace "Dump " at start of docstring with "Append " (borrowed
412 from [deleted] deprecated_add_show_from_set). */
413 if ( c->doc[0] == 'W'
419 c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
422 /* Opaque data for restore_section_callback. */
423 struct callback_data {
424 CORE_ADDR load_offset;
425 CORE_ADDR load_start;
429 /* Function: restore_section_callback.
431 Callback function for bfd_map_over_sections.
432 Selectively loads the sections into memory. */
435 restore_section_callback (bfd *ibfd, asection *isec, void *args)
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;
447 /* Ignore non-loadable sections, eg. from elf files. */
448 if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
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))
455 /* No, no useable data in this section. */
456 printf_filtered (_("skipping section %s...\n"),
457 bfd_section_name (ibfd, isec));
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;
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 ()));
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);
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));
492 puts_filtered ("\n");
494 /* Write the data. */
495 ret = target_write_memory (sec_start + sec_offset + data->load_offset,
496 buf + sec_offset, sec_load_count);
498 warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
499 do_cleanups (old_chain);
504 restore_binary_file (const char *filename, struct callback_data *data)
506 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
507 FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
511 /* Get the file size for reading. */
512 if (fseek (file, 0, SEEK_END) == 0)
516 perror_with_name (filename);
519 perror_with_name (filename);
521 if (len <= data->load_start)
522 error (_("Start address is greater than length of binary file %s."),
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;
533 ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
535 (unsigned long) (data->load_start + data->load_offset),
536 (unsigned long) (data->load_start + data->load_offset + len));
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);
542 /* Now allocate a buffer and read the file contents. */
544 make_cleanup (xfree, buf);
545 if (fread (buf, 1, len, file) != len)
546 perror_with_name (filename);
548 /* Now write the buffer into target memory. */
549 len = target_write_memory (data->load_start + data->load_offset, buf, len);
551 warning (_("restore: memory write failed (%s)."), safe_strerror (len));
552 do_cleanups (cleanup);
556 restore_command (char *args_in, int from_tty)
559 struct callback_data data;
562 const char *args = args_in;
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_const (args);
584 /* Parse offset (optional). */
585 if (args != NULL && *args != '\0')
587 parse_and_eval_address (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 ", all_commands, 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 ", all_commands, 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 ", all_commands, 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 ", all_commands, 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 ", all_commands,
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. */