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 {
431 CORE_ADDR load_offset;
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 (%s to %s)\n",
492 paddress (target_gdbarch,
493 (unsigned long) sec_start
494 + sec_offset + data->load_offset),
495 paddress (target_gdbarch,
496 (unsigned long) sec_start + sec_offset
497 + data->load_offset + sec_load_count));
499 puts_filtered ("\n");
501 /* Write the data. */
502 ret = target_write_memory (sec_start + sec_offset + data->load_offset,
503 buf + sec_offset, sec_load_count);
505 warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
506 do_cleanups (old_chain);
511 restore_binary_file (char *filename, struct callback_data *data)
513 FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
518 /* Get the file size for reading. */
519 if (fseek (file, 0, SEEK_END) == 0)
522 perror_with_name (filename);
524 if (len <= data->load_start)
525 error (_("Start address is greater than length of binary file %s."),
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;
536 ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
538 (unsigned long) (data->load_start + data->load_offset),
539 (unsigned long) (data->load_start + data->load_offset + len));
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);
545 /* Now allocate a buffer and read the file contents. */
547 make_cleanup (xfree, buf);
548 if (fread (buf, 1, len, file) != len)
549 perror_with_name (filename);
551 /* Now write the buffer into target memory. */
552 len = target_write_memory (data->load_start + data->load_offset, buf, len);
554 warning (_("restore: memory write failed (%s)."), safe_strerror (len));
559 restore_command (char *args, int from_tty)
562 struct callback_data data;
566 if (!target_has_execution)
569 data.load_offset = 0;
573 /* Parse the input arguments. First is filename (required). */
574 filename = scan_filename_with_cleanup (&args, NULL);
575 if (args != NULL && *args != '\0')
577 char *binary_string = "binary";
579 /* Look for optional "binary" flag. */
580 if (strncmp (args, binary_string, strlen (binary_string)) == 0)
583 args += strlen (binary_string);
584 args = skip_spaces (args);
586 /* Parse offset (optional). */
587 if (args != NULL && *args != '\0')
589 parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
590 if (args != NULL && *args != '\0')
592 /* Parse start address (optional). */
594 parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
595 if (args != NULL && *args != '\0')
597 /* Parse end address (optional). */
598 data.load_end = parse_and_eval_long (args);
599 if (data.load_end <= data.load_start)
600 error (_("Start must be less than end."));
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);
613 restore_binary_file (filename, &data);
617 /* Open the file for loading. */
618 ibfd = bfd_openr_with_cleanup (filename, NULL);
620 /* Process the sections. */
621 bfd_map_over_sections (ibfd, restore_section_callback, &data);
627 srec_dump_command (char *cmd, int from_tty)
629 printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
630 help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
634 ihex_dump_command (char *cmd, int from_tty)
636 printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
637 help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
641 tekhex_dump_command (char *cmd, int from_tty)
643 printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
644 help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
648 binary_dump_command (char *cmd, int from_tty)
650 printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
651 help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
655 binary_append_command (char *cmd, int from_tty)
657 printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
658 help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
661 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
664 _initialize_cli_dump (void)
666 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 specifed 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 specifed 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 specifed 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 specifed 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 specifed 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 specifed 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. */