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/>. */
24 #include "cli/cli-decode.h"
25 #include "cli/cli-cmds.h"
27 #include "completer.h"
28 #include "gdb_assert.h"
31 #include "readline/readline.h"
33 #include "cli/cli-utils.h"
35 #include "filestuff.h"
39 scan_expression_with_cleanup (const char **cmd
, const char *def
)
41 if ((*cmd
) == NULL
|| (**cmd
) == '\0')
43 char *exp
= xstrdup (def
);
45 make_cleanup (xfree
, exp
);
53 end
= (*cmd
) + strcspn (*cmd
, " \t");
54 exp
= savestring ((*cmd
), end
- (*cmd
));
55 make_cleanup (xfree
, exp
);
56 (*cmd
) = skip_spaces_const (end
);
63 scan_filename_with_cleanup (const char **cmd
, const char *defname
)
68 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
74 error (_("Missing filename."));
75 filename
= xstrdup (defname
);
76 make_cleanup (xfree
, filename
);
80 /* FIXME: should parse a possibly quoted string. */
83 (*cmd
) = skip_spaces_const (*cmd
);
84 end
= *cmd
+ strcspn (*cmd
, " \t");
85 filename
= savestring ((*cmd
), end
- (*cmd
));
86 make_cleanup (xfree
, filename
);
87 (*cmd
) = skip_spaces_const (end
);
89 gdb_assert (filename
!= NULL
);
91 fullname
= tilde_expand (filename
);
92 make_cleanup (xfree
, fullname
);
98 fopen_with_cleanup (const char *filename
, const char *mode
)
100 FILE *file
= gdb_fopen_cloexec (filename
, mode
);
103 perror_with_name (filename
);
104 make_cleanup_fclose (file
);
109 bfd_openr_with_cleanup (const char *filename
, const char *target
)
113 ibfd
= gdb_bfd_openr (filename
, target
);
115 error (_("Failed to open %s: %s."), filename
,
116 bfd_errmsg (bfd_get_error ()));
118 make_cleanup_bfd_unref (ibfd
);
119 if (!bfd_check_format (ibfd
, bfd_object
))
120 error (_("'%s' is not a recognized file format."), filename
);
126 bfd_openw_with_cleanup (const char *filename
, const char *target
,
131 if (*mode
== 'w') /* Write: create new file */
133 obfd
= gdb_bfd_openw (filename
, target
);
135 error (_("Failed to open %s: %s."), filename
,
136 bfd_errmsg (bfd_get_error ()));
137 make_cleanup_bfd_unref (obfd
);
138 if (!bfd_set_format (obfd
, bfd_object
))
139 error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
141 else if (*mode
== 'a') /* Append to existing file. */
142 { /* FIXME -- doesn't work... */
143 error (_("bfd_openw does not work with append."));
146 error (_("bfd_openw_with_cleanup: unknown mode %s."), mode
);
151 static struct cmd_list_element
*dump_cmdlist
;
152 static struct cmd_list_element
*append_cmdlist
;
153 static struct cmd_list_element
*srec_cmdlist
;
154 static struct cmd_list_element
*ihex_cmdlist
;
155 static struct cmd_list_element
*tekhex_cmdlist
;
156 static struct cmd_list_element
*binary_dump_cmdlist
;
157 static struct cmd_list_element
*binary_append_cmdlist
;
160 dump_command (char *cmd
, int from_tty
)
162 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
163 help_list (dump_cmdlist
, "dump ", all_commands
, gdb_stdout
);
167 append_command (char *cmd
, int from_tty
)
169 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
170 help_list (dump_cmdlist
, "append ", all_commands
, gdb_stdout
);
174 dump_binary_file (const char *filename
, const char *mode
,
175 const bfd_byte
*buf
, ULONGEST len
)
180 file
= fopen_with_cleanup (filename
, mode
);
181 status
= fwrite (buf
, len
, 1, file
);
183 perror_with_name (filename
);
187 dump_bfd_file (const char *filename
, const char *mode
,
188 const char *target
, CORE_ADDR vaddr
,
189 const bfd_byte
*buf
, ULONGEST len
)
194 obfd
= bfd_openw_with_cleanup (filename
, target
, mode
);
195 osection
= bfd_make_section_anyway (obfd
, ".newsec");
196 bfd_set_section_size (obfd
, osection
, len
);
197 bfd_set_section_vma (obfd
, osection
, vaddr
);
198 bfd_set_section_alignment (obfd
, osection
, 0);
199 bfd_set_section_flags (obfd
, osection
, (SEC_HAS_CONTENTS
202 osection
->entsize
= 0;
203 if (!bfd_set_section_contents (obfd
, osection
, buf
, 0, len
))
204 warning (_("writing dump file '%s' (%s)"), filename
,
205 bfd_errmsg (bfd_get_error ()));
209 dump_memory_to_file (const char *cmd
, const char *mode
, const char *file_format
)
211 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
215 const char *filename
;
221 filename
= scan_filename_with_cleanup (&cmd
, NULL
);
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
);
228 /* Find the second address - rest of line. */
229 if (cmd
== NULL
|| *cmd
== '\0')
230 error (_("Missing stop address."));
233 lo
= parse_and_eval_address (lo_exp
);
234 hi
= parse_and_eval_address (hi_exp
);
236 error (_("Invalid memory address range (start >= end)."));
239 /* FIXME: Should use read_memory_partial() and a magic blocking
241 buf
= xmalloc (count
);
242 make_cleanup (xfree
, buf
);
243 read_memory (lo
, buf
, count
);
245 /* Have everything. Open/write the data. */
246 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
248 dump_binary_file (filename
, mode
, buf
, count
);
252 dump_bfd_file (filename
, mode
, file_format
, lo
, buf
, count
);
255 do_cleanups (old_cleanups
);
259 dump_memory_command (char *cmd
, char *mode
)
261 dump_memory_to_file (cmd
, mode
, "binary");
265 dump_value_to_file (const char *cmd
, const char *mode
, const char *file_format
)
267 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
269 const char *filename
;
272 filename
= scan_filename_with_cleanup (&cmd
, NULL
);
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
);
279 error (_("Invalid expression."));
281 /* Have everything. Open/write the data. */
282 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
284 dump_binary_file (filename
, mode
, value_contents (val
),
285 TYPE_LENGTH (value_type (val
)));
291 if (VALUE_LVAL (val
))
293 vaddr
= value_address (val
);
298 warning (_("value is not an lval: address assumed to be zero"));
301 dump_bfd_file (filename
, mode
, file_format
, vaddr
,
302 value_contents (val
),
303 TYPE_LENGTH (value_type (val
)));
306 do_cleanups (old_cleanups
);
310 dump_value_command (char *cmd
, char *mode
)
312 dump_value_to_file (cmd
, mode
, "binary");
316 dump_srec_memory (char *args
, int from_tty
)
318 dump_memory_to_file (args
, FOPEN_WB
, "srec");
322 dump_srec_value (char *args
, int from_tty
)
324 dump_value_to_file (args
, FOPEN_WB
, "srec");
328 dump_ihex_memory (char *args
, int from_tty
)
330 dump_memory_to_file (args
, FOPEN_WB
, "ihex");
334 dump_ihex_value (char *args
, int from_tty
)
336 dump_value_to_file (args
, FOPEN_WB
, "ihex");
340 dump_tekhex_memory (char *args
, int from_tty
)
342 dump_memory_to_file (args
, FOPEN_WB
, "tekhex");
346 dump_tekhex_value (char *args
, int from_tty
)
348 dump_value_to_file (args
, FOPEN_WB
, "tekhex");
352 dump_binary_memory (char *args
, int from_tty
)
354 dump_memory_to_file (args
, FOPEN_WB
, "binary");
358 dump_binary_value (char *args
, int from_tty
)
360 dump_value_to_file (args
, FOPEN_WB
, "binary");
364 append_binary_memory (char *args
, int from_tty
)
366 dump_memory_to_file (args
, FOPEN_AB
, "binary");
370 append_binary_value (char *args
, int from_tty
)
372 dump_value_to_file (args
, FOPEN_AB
, "binary");
377 void (*func
) (char *cmd
, char *mode
);
382 call_dump_func (struct cmd_list_element
*c
, char *args
, int from_tty
)
384 struct dump_context
*d
= get_cmd_context (c
);
386 d
->func (args
, d
->mode
);
390 add_dump_command (char *name
, void (*func
) (char *args
, char *mode
),
394 struct cmd_list_element
*c
;
395 struct dump_context
*d
;
397 c
= add_cmd (name
, all_commands
, NULL
, descr
, &dump_cmdlist
);
398 c
->completer
= filename_completer
;
399 d
= XNEW (struct dump_context
);
402 set_cmd_context (c
, d
);
403 c
->func
= call_dump_func
;
405 c
= add_cmd (name
, all_commands
, NULL
, descr
, &append_cmdlist
);
406 c
->completer
= filename_completer
;
407 d
= XNEW (struct dump_context
);
410 set_cmd_context (c
, d
);
411 c
->func
= call_dump_func
;
413 /* Replace "Dump " at start of docstring with "Append " (borrowed
414 from [deleted] deprecated_add_show_from_set). */
415 if ( c
->doc
[0] == 'W'
421 c
->doc
= concat ("Append ", c
->doc
+ 6, (char *)NULL
);
424 /* Opaque data for restore_section_callback. */
425 struct callback_data
{
426 CORE_ADDR load_offset
;
427 CORE_ADDR load_start
;
431 /* Function: restore_section_callback.
433 Callback function for bfd_map_over_sections.
434 Selectively loads the sections into memory. */
437 restore_section_callback (bfd
*ibfd
, asection
*isec
, void *args
)
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
;
449 /* Ignore non-loadable sections, eg. from elf files. */
450 if (!(bfd_get_section_flags (ibfd
, isec
) & SEC_LOAD
))
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
))
457 /* No, no useable data in this section. */
458 printf_filtered (_("skipping section %s...\n"),
459 bfd_section_name (ibfd
, isec
));
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
;
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 ()));
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
);
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
));
494 puts_filtered ("\n");
496 /* Write the data. */
497 ret
= target_write_memory (sec_start
+ sec_offset
+ data
->load_offset
,
498 buf
+ sec_offset
, sec_load_count
);
500 warning (_("restore: memory write failed (%s)."), safe_strerror (ret
));
501 do_cleanups (old_chain
);
506 restore_binary_file (const char *filename
, struct callback_data
*data
)
508 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
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
));
554 do_cleanups (cleanup
);
558 restore_command (char *args_in
, int from_tty
)
561 struct callback_data data
;
564 const char *args
= args_in
;
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_const (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 ", all_commands
, 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 ", all_commands
, 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 ", all_commands
, 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 ", all_commands
, 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 ", all_commands
,
662 extern initialize_file_ftype _initialize_cli_dump
; /* -Wmissing-prototypes */
665 _initialize_cli_dump (void)
667 struct cmd_list_element
*c
;
669 add_prefix_cmd ("dump", class_vars
, dump_command
,
670 _("Dump target code/data to a local file."),
671 &dump_cmdlist
, "dump ",
674 add_prefix_cmd ("append", class_vars
, append_command
,
675 _("Append target code/data to a local file."),
676 &append_cmdlist
, "append ",
680 add_dump_command ("memory", dump_memory_command
, "\
681 Write contents of memory to a raw binary file.\n\
682 Arguments are FILE START STOP. Writes the contents of memory within the\n\
683 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
685 add_dump_command ("value", dump_value_command
, "\
686 Write the value of an expression to a raw binary file.\n\
687 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
688 the specified FILE in raw target ordered bytes.");
690 add_prefix_cmd ("srec", all_commands
, srec_dump_command
,
691 _("Write target code/data to an srec file."),
692 &srec_cmdlist
, "dump srec ",
696 add_prefix_cmd ("ihex", all_commands
, ihex_dump_command
,
697 _("Write target code/data to an intel hex file."),
698 &ihex_cmdlist
, "dump ihex ",
702 add_prefix_cmd ("tekhex", all_commands
, tekhex_dump_command
,
703 _("Write target code/data to a tekhex file."),
704 &tekhex_cmdlist
, "dump tekhex ",
708 add_prefix_cmd ("binary", all_commands
, binary_dump_command
,
709 _("Write target code/data to a raw binary file."),
710 &binary_dump_cmdlist
, "dump binary ",
714 add_prefix_cmd ("binary", all_commands
, binary_append_command
,
715 _("Append target code/data to a raw binary file."),
716 &binary_append_cmdlist
, "append binary ",
720 add_cmd ("memory", all_commands
, dump_srec_memory
, _("\
721 Write contents of memory to an srec file.\n\
722 Arguments are FILE START STOP. Writes the contents of memory\n\
723 within the range [START .. STOP) to the specified FILE in srec format."),
726 add_cmd ("value", all_commands
, dump_srec_value
, _("\
727 Write the value of an expression to an srec file.\n\
728 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
729 to the specified FILE in srec format."),
732 add_cmd ("memory", all_commands
, dump_ihex_memory
, _("\
733 Write contents of memory to an ihex file.\n\
734 Arguments are FILE START STOP. Writes the contents of memory within\n\
735 the range [START .. STOP) to the specified FILE in intel hex format."),
738 add_cmd ("value", all_commands
, dump_ihex_value
, _("\
739 Write the value of an expression to an ihex file.\n\
740 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
741 to the specified FILE in intel hex format."),
744 add_cmd ("memory", all_commands
, dump_tekhex_memory
, _("\
745 Write contents of memory to a tekhex file.\n\
746 Arguments are FILE START STOP. Writes the contents of memory\n\
747 within the range [START .. STOP) to the specified FILE in tekhex format."),
750 add_cmd ("value", all_commands
, dump_tekhex_value
, _("\
751 Write the value of an expression to a tekhex file.\n\
752 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
753 to the specified FILE in tekhex format."),
756 add_cmd ("memory", all_commands
, dump_binary_memory
, _("\
757 Write contents of memory to a raw binary file.\n\
758 Arguments are FILE START STOP. Writes the contents of memory\n\
759 within the range [START .. STOP) to the specified FILE in binary format."),
760 &binary_dump_cmdlist
);
762 add_cmd ("value", all_commands
, dump_binary_value
, _("\
763 Write the value of an expression to a raw binary file.\n\
764 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
765 to the specified FILE in raw target ordered bytes."),
766 &binary_dump_cmdlist
);
768 add_cmd ("memory", all_commands
, append_binary_memory
, _("\
769 Append contents of memory to a raw binary file.\n\
770 Arguments are FILE START STOP. Writes the contents of memory within the\n\
771 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
772 &binary_append_cmdlist
);
774 add_cmd ("value", all_commands
, append_binary_value
, _("\
775 Append the value of an expression to a raw binary file.\n\
776 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
777 to the specified FILE in raw target ordered bytes."),
778 &binary_append_cmdlist
);
780 c
= add_com ("restore", class_vars
, restore_command
, _("\
781 Restore the contents of FILE to target memory.\n\
782 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
783 OFFSET will be added to the base address of the file (default zero).\n\
784 If START and END are given, only the file contents within that range\n\
785 (file relative) will be restored to target memory."));
786 c
->completer
= filename_completer
;
787 /* FIXME: completers for other commands. */