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"
37 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
41 scan_expression_with_cleanup (char **cmd
, const char *def
)
43 if ((*cmd
) == NULL
|| (**cmd
) == '\0')
45 char *exp
= xstrdup (def
);
47 make_cleanup (xfree
, exp
);
55 end
= (*cmd
) + strcspn (*cmd
, " \t");
56 exp
= savestring ((*cmd
), end
- (*cmd
));
57 make_cleanup (xfree
, exp
);
58 (*cmd
) = skip_spaces (end
);
65 scan_filename_with_cleanup (char **cmd
, const char *defname
)
70 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
76 error (_("Missing filename."));
77 filename
= xstrdup (defname
);
78 make_cleanup (xfree
, filename
);
82 /* FIXME: should parse a possibly quoted string. */
85 (*cmd
) = skip_spaces (*cmd
);
86 end
= *cmd
+ strcspn (*cmd
, " \t");
87 filename
= savestring ((*cmd
), end
- (*cmd
));
88 make_cleanup (xfree
, filename
);
89 (*cmd
) = skip_spaces (end
);
91 gdb_assert (filename
!= NULL
);
93 fullname
= tilde_expand (filename
);
94 make_cleanup (xfree
, fullname
);
100 fopen_with_cleanup (const char *filename
, const char *mode
)
102 FILE *file
= fopen (filename
, mode
);
105 perror_with_name (filename
);
106 make_cleanup_fclose (file
);
111 bfd_openr_with_cleanup (const char *filename
, const char *target
)
115 ibfd
= gdb_bfd_ref (bfd_openr (filename
, target
));
117 error (_("Failed to open %s: %s."), filename
,
118 bfd_errmsg (bfd_get_error ()));
120 make_cleanup_bfd_close (ibfd
);
121 if (!bfd_check_format (ibfd
, bfd_object
))
122 error (_("'%s' is not a recognized file format."), filename
);
128 bfd_openw_with_cleanup (const char *filename
, const char *target
,
133 if (*mode
== 'w') /* Write: create new file */
135 obfd
= gdb_bfd_ref (bfd_openw (filename
, target
));
137 error (_("Failed to open %s: %s."), filename
,
138 bfd_errmsg (bfd_get_error ()));
139 make_cleanup_bfd_close (obfd
);
140 if (!bfd_set_format (obfd
, bfd_object
))
141 error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
143 else if (*mode
== 'a') /* Append to existing file. */
144 { /* FIXME -- doesn't work... */
145 error (_("bfd_openw does not work with append."));
148 error (_("bfd_openw_with_cleanup: unknown mode %s."), mode
);
153 struct cmd_list_element
*dump_cmdlist
;
154 struct cmd_list_element
*append_cmdlist
;
155 struct cmd_list_element
*srec_cmdlist
;
156 struct cmd_list_element
*ihex_cmdlist
;
157 struct cmd_list_element
*tekhex_cmdlist
;
158 struct cmd_list_element
*binary_dump_cmdlist
;
159 struct cmd_list_element
*binary_append_cmdlist
;
162 dump_command (char *cmd
, int from_tty
)
164 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
165 help_list (dump_cmdlist
, "dump ", -1, gdb_stdout
);
169 append_command (char *cmd
, int from_tty
)
171 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
172 help_list (dump_cmdlist
, "append ", -1, gdb_stdout
);
176 dump_binary_file (const char *filename
, const char *mode
,
177 const bfd_byte
*buf
, ULONGEST len
)
182 file
= fopen_with_cleanup (filename
, mode
);
183 status
= fwrite (buf
, len
, 1, file
);
185 perror_with_name (filename
);
189 dump_bfd_file (const char *filename
, const char *mode
,
190 const char *target
, CORE_ADDR vaddr
,
191 const bfd_byte
*buf
, ULONGEST len
)
196 obfd
= bfd_openw_with_cleanup (filename
, target
, mode
);
197 osection
= bfd_make_section_anyway (obfd
, ".newsec");
198 bfd_set_section_size (obfd
, osection
, len
);
199 bfd_set_section_vma (obfd
, osection
, vaddr
);
200 bfd_set_section_alignment (obfd
, osection
, 0);
201 bfd_set_section_flags (obfd
, osection
, (SEC_HAS_CONTENTS
204 osection
->entsize
= 0;
205 if (!bfd_set_section_contents (obfd
, osection
, buf
, 0, len
))
206 warning (_("writing dump file '%s' (%s)"), filename
,
207 bfd_errmsg (bfd_get_error ()));
211 dump_memory_to_file (char *cmd
, char *mode
, char *file_format
)
213 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
223 filename
= scan_filename_with_cleanup (&cmd
, NULL
);
225 /* Find the low address. */
226 if (cmd
== NULL
|| *cmd
== '\0')
227 error (_("Missing start address."));
228 lo_exp
= scan_expression_with_cleanup (&cmd
, NULL
);
230 /* Find the second address - rest of line. */
231 if (cmd
== NULL
|| *cmd
== '\0')
232 error (_("Missing stop address."));
235 lo
= parse_and_eval_address (lo_exp
);
236 hi
= parse_and_eval_address (hi_exp
);
238 error (_("Invalid memory address range (start >= end)."));
241 /* FIXME: Should use read_memory_partial() and a magic blocking
243 buf
= xmalloc (count
);
244 make_cleanup (xfree
, buf
);
245 read_memory (lo
, buf
, count
);
247 /* Have everything. Open/write the data. */
248 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
250 dump_binary_file (filename
, mode
, buf
, count
);
254 dump_bfd_file (filename
, mode
, file_format
, lo
, buf
, count
);
257 do_cleanups (old_cleanups
);
261 dump_memory_command (char *cmd
, char *mode
)
263 dump_memory_to_file (cmd
, mode
, "binary");
267 dump_value_to_file (char *cmd
, char *mode
, char *file_format
)
269 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
274 filename
= scan_filename_with_cleanup (&cmd
, NULL
);
276 /* Find the value. */
277 if (cmd
== NULL
|| *cmd
== '\0')
278 error (_("No value to %s."), *mode
== 'a' ? "append" : "dump");
279 val
= parse_and_eval (cmd
);
281 error (_("Invalid expression."));
283 /* Have everything. Open/write the data. */
284 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
286 dump_binary_file (filename
, mode
, value_contents (val
),
287 TYPE_LENGTH (value_type (val
)));
293 if (VALUE_LVAL (val
))
295 vaddr
= value_address (val
);
300 warning (_("value is not an lval: address assumed to be zero"));
303 dump_bfd_file (filename
, mode
, file_format
, vaddr
,
304 value_contents (val
),
305 TYPE_LENGTH (value_type (val
)));
308 do_cleanups (old_cleanups
);
312 dump_value_command (char *cmd
, char *mode
)
314 dump_value_to_file (cmd
, mode
, "binary");
318 dump_srec_memory (char *args
, int from_tty
)
320 dump_memory_to_file (args
, FOPEN_WB
, "srec");
324 dump_srec_value (char *args
, int from_tty
)
326 dump_value_to_file (args
, FOPEN_WB
, "srec");
330 dump_ihex_memory (char *args
, int from_tty
)
332 dump_memory_to_file (args
, FOPEN_WB
, "ihex");
336 dump_ihex_value (char *args
, int from_tty
)
338 dump_value_to_file (args
, FOPEN_WB
, "ihex");
342 dump_tekhex_memory (char *args
, int from_tty
)
344 dump_memory_to_file (args
, FOPEN_WB
, "tekhex");
348 dump_tekhex_value (char *args
, int from_tty
)
350 dump_value_to_file (args
, FOPEN_WB
, "tekhex");
354 dump_binary_memory (char *args
, int from_tty
)
356 dump_memory_to_file (args
, FOPEN_WB
, "binary");
360 dump_binary_value (char *args
, int from_tty
)
362 dump_value_to_file (args
, FOPEN_WB
, "binary");
366 append_binary_memory (char *args
, int from_tty
)
368 dump_memory_to_file (args
, FOPEN_AB
, "binary");
372 append_binary_value (char *args
, int from_tty
)
374 dump_value_to_file (args
, FOPEN_AB
, "binary");
379 void (*func
) (char *cmd
, char *mode
);
384 call_dump_func (struct cmd_list_element
*c
, char *args
, int from_tty
)
386 struct dump_context
*d
= get_cmd_context (c
);
388 d
->func (args
, d
->mode
);
392 add_dump_command (char *name
, void (*func
) (char *args
, char *mode
),
396 struct cmd_list_element
*c
;
397 struct dump_context
*d
;
399 c
= add_cmd (name
, all_commands
, NULL
, descr
, &dump_cmdlist
);
400 c
->completer
= filename_completer
;
401 d
= XMALLOC (struct dump_context
);
404 set_cmd_context (c
, d
);
405 c
->func
= call_dump_func
;
407 c
= add_cmd (name
, all_commands
, NULL
, descr
, &append_cmdlist
);
408 c
->completer
= filename_completer
;
409 d
= XMALLOC (struct dump_context
);
412 set_cmd_context (c
, d
);
413 c
->func
= call_dump_func
;
415 /* Replace "Dump " at start of docstring with "Append " (borrowed
416 from [deleted] deprecated_add_show_from_set). */
417 if ( c
->doc
[0] == 'W'
423 c
->doc
= concat ("Append ", c
->doc
+ 6, (char *)NULL
);
426 /* Opaque data for restore_section_callback. */
427 struct callback_data
{
428 CORE_ADDR load_offset
;
429 CORE_ADDR load_start
;
433 /* Function: restore_section_callback.
435 Callback function for bfd_map_over_sections.
436 Selectively loads the sections into memory. */
439 restore_section_callback (bfd
*ibfd
, asection
*isec
, void *args
)
441 struct callback_data
*data
= args
;
442 bfd_vma sec_start
= bfd_section_vma (ibfd
, isec
);
443 bfd_size_type size
= bfd_section_size (ibfd
, isec
);
444 bfd_vma sec_end
= sec_start
+ size
;
445 bfd_size_type sec_offset
= 0;
446 bfd_size_type sec_load_count
= size
;
447 struct cleanup
*old_chain
;
451 /* Ignore non-loadable sections, eg. from elf files. */
452 if (!(bfd_get_section_flags (ibfd
, isec
) & SEC_LOAD
))
455 /* Does the section overlap with the desired restore range? */
456 if (sec_end
<= data
->load_start
457 || (data
->load_end
> 0 && sec_start
>= data
->load_end
))
459 /* No, no useable data in this section. */
460 printf_filtered (_("skipping section %s...\n"),
461 bfd_section_name (ibfd
, isec
));
465 /* Compare section address range with user-requested
466 address range (if any). Compute where the actual
467 transfer should start and end. */
468 if (sec_start
< data
->load_start
)
469 sec_offset
= data
->load_start
- sec_start
;
470 /* Size of a partial transfer. */
471 sec_load_count
-= sec_offset
;
472 if (data
->load_end
> 0 && sec_end
> data
->load_end
)
473 sec_load_count
-= sec_end
- data
->load_end
;
476 buf
= xmalloc (size
);
477 old_chain
= make_cleanup (xfree
, buf
);
478 if (!bfd_get_section_contents (ibfd
, isec
, buf
, 0, size
))
479 error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd
),
480 bfd_errmsg (bfd_get_error ()));
482 printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
483 bfd_section_name (ibfd
, isec
),
484 (unsigned long) sec_start
,
485 (unsigned long) sec_end
);
487 if (data
->load_offset
!= 0 || data
->load_start
!= 0 || data
->load_end
!= 0)
488 printf_filtered (" into memory (%s to %s)\n",
489 paddress (target_gdbarch
,
490 (unsigned long) sec_start
491 + sec_offset
+ data
->load_offset
),
492 paddress (target_gdbarch
,
493 (unsigned long) sec_start
+ sec_offset
494 + data
->load_offset
+ sec_load_count
));
496 puts_filtered ("\n");
498 /* Write the data. */
499 ret
= target_write_memory (sec_start
+ sec_offset
+ data
->load_offset
,
500 buf
+ sec_offset
, sec_load_count
);
502 warning (_("restore: memory write failed (%s)."), safe_strerror (ret
));
503 do_cleanups (old_chain
);
508 restore_binary_file (char *filename
, struct callback_data
*data
)
510 FILE *file
= fopen_with_cleanup (filename
, FOPEN_RB
);
514 /* Get the file size for reading. */
515 if (fseek (file
, 0, SEEK_END
) == 0)
519 perror_with_name (filename
);
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
;
668 add_prefix_cmd ("dump", class_vars
, dump_command
,
669 _("Dump target code/data to a local file."),
670 &dump_cmdlist
, "dump ",
673 add_prefix_cmd ("append", class_vars
, append_command
,
674 _("Append target code/data to a local file."),
675 &append_cmdlist
, "append ",
679 add_dump_command ("memory", dump_memory_command
, "\
680 Write contents of memory to a raw binary file.\n\
681 Arguments are FILE START STOP. Writes the contents of memory within the\n\
682 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
684 add_dump_command ("value", dump_value_command
, "\
685 Write the value of an expression to a raw binary file.\n\
686 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
687 the specified FILE in raw target ordered bytes.");
689 add_prefix_cmd ("srec", all_commands
, srec_dump_command
,
690 _("Write target code/data to an srec file."),
691 &srec_cmdlist
, "dump srec ",
695 add_prefix_cmd ("ihex", all_commands
, ihex_dump_command
,
696 _("Write target code/data to an intel hex file."),
697 &ihex_cmdlist
, "dump ihex ",
701 add_prefix_cmd ("tekhex", all_commands
, tekhex_dump_command
,
702 _("Write target code/data to a tekhex file."),
703 &tekhex_cmdlist
, "dump tekhex ",
707 add_prefix_cmd ("binary", all_commands
, binary_dump_command
,
708 _("Write target code/data to a raw binary file."),
709 &binary_dump_cmdlist
, "dump binary ",
713 add_prefix_cmd ("binary", all_commands
, binary_append_command
,
714 _("Append target code/data to a raw binary file."),
715 &binary_append_cmdlist
, "append binary ",
719 add_cmd ("memory", all_commands
, dump_srec_memory
, _("\
720 Write contents of memory to an srec file.\n\
721 Arguments are FILE START STOP. Writes the contents of memory\n\
722 within the range [START .. STOP) to the specified FILE in srec format."),
725 add_cmd ("value", all_commands
, dump_srec_value
, _("\
726 Write the value of an expression to an srec file.\n\
727 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
728 to the specified FILE in srec format."),
731 add_cmd ("memory", all_commands
, dump_ihex_memory
, _("\
732 Write contents of memory to an ihex file.\n\
733 Arguments are FILE START STOP. Writes the contents of memory within\n\
734 the range [START .. STOP) to the specified FILE in intel hex format."),
737 add_cmd ("value", all_commands
, dump_ihex_value
, _("\
738 Write the value of an expression to an ihex file.\n\
739 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
740 to the specified FILE in intel hex format."),
743 add_cmd ("memory", all_commands
, dump_tekhex_memory
, _("\
744 Write contents of memory to a tekhex file.\n\
745 Arguments are FILE START STOP. Writes the contents of memory\n\
746 within the range [START .. STOP) to the specified FILE in tekhex format."),
749 add_cmd ("value", all_commands
, dump_tekhex_value
, _("\
750 Write the value of an expression to a tekhex file.\n\
751 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
752 to the specified FILE in tekhex format."),
755 add_cmd ("memory", all_commands
, dump_binary_memory
, _("\
756 Write contents of memory to a raw binary file.\n\
757 Arguments are FILE START STOP. Writes the contents of memory\n\
758 within the range [START .. STOP) to the specified FILE in binary format."),
759 &binary_dump_cmdlist
);
761 add_cmd ("value", all_commands
, dump_binary_value
, _("\
762 Write the value of an expression to a raw binary file.\n\
763 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
764 to the specified FILE in raw target ordered bytes."),
765 &binary_dump_cmdlist
);
767 add_cmd ("memory", all_commands
, append_binary_memory
, _("\
768 Append contents of memory to a raw binary file.\n\
769 Arguments are FILE START STOP. Writes the contents of memory within the\n\
770 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
771 &binary_append_cmdlist
);
773 add_cmd ("value", all_commands
, append_binary_value
, _("\
774 Append the value of an expression to a raw binary file.\n\
775 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
776 to the specified FILE in raw target ordered bytes."),
777 &binary_append_cmdlist
);
779 c
= add_com ("restore", class_vars
, restore_command
, _("\
780 Restore the contents of FILE to target memory.\n\
781 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
782 OFFSET will be added to the base address of the file (default zero).\n\
783 If START and END are given, only the file contents within that range\n\
784 (file relative) will be restored to target memory."));
785 c
->completer
= filename_completer
;
786 /* FIXME: completers for other commands. */