1 /* Dump-to-file commands, for GDB, the GNU debugger.
3 Copyright (c) 2002, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Red Hat.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
25 #include "cli/cli-decode.h"
26 #include "cli/cli-cmds.h"
28 #include "completer.h"
29 #include "cli/cli-dump.h"
30 #include "gdb_assert.h"
33 #include "readline/readline.h"
36 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
40 skip_spaces (char *chp
)
44 while (isspace (*chp
))
50 scan_expression_with_cleanup (char **cmd
, const char *def
)
52 if ((*cmd
) == NULL
|| (**cmd
) == '\0')
54 char *exp
= xstrdup (def
);
55 make_cleanup (xfree
, exp
);
63 end
= (*cmd
) + strcspn (*cmd
, " \t");
64 exp
= savestring ((*cmd
), end
- (*cmd
));
65 make_cleanup (xfree
, exp
);
66 (*cmd
) = skip_spaces (end
);
73 scan_filename_with_cleanup (char **cmd
, const char *defname
)
78 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
84 error (_("Missing filename."));
85 filename
= xstrdup (defname
);
86 make_cleanup (xfree
, filename
);
90 /* FIXME: should parse a possibly quoted string. */
93 (*cmd
) = skip_spaces (*cmd
);
94 end
= *cmd
+ strcspn (*cmd
, " \t");
95 filename
= savestring ((*cmd
), end
- (*cmd
));
96 make_cleanup (xfree
, filename
);
97 (*cmd
) = skip_spaces (end
);
99 gdb_assert (filename
!= NULL
);
101 fullname
= tilde_expand (filename
);
102 make_cleanup (xfree
, fullname
);
108 fopen_with_cleanup (const char *filename
, const char *mode
)
110 FILE *file
= fopen (filename
, mode
);
112 perror_with_name (filename
);
113 make_cleanup_fclose (file
);
118 bfd_openr_with_cleanup (const char *filename
, const char *target
)
122 ibfd
= bfd_openr (filename
, target
);
124 error (_("Failed to open %s: %s."), filename
,
125 bfd_errmsg (bfd_get_error ()));
127 make_cleanup_bfd_close (ibfd
);
128 if (!bfd_check_format (ibfd
, bfd_object
))
129 error (_("'%s' is not a recognized file format."), filename
);
135 bfd_openw_with_cleanup (const char *filename
, const char *target
,
140 if (*mode
== 'w') /* Write: create new file */
142 obfd
= bfd_openw (filename
, target
);
144 error (_("Failed to open %s: %s."), filename
,
145 bfd_errmsg (bfd_get_error ()));
146 make_cleanup_bfd_close (obfd
);
147 if (!bfd_set_format (obfd
, bfd_object
))
148 error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
150 else if (*mode
== 'a') /* Append to existing file */
151 { /* FIXME -- doesn't work... */
152 error (_("bfd_openw does not work with append."));
155 error (_("bfd_openw_with_cleanup: unknown mode %s."), mode
);
160 struct cmd_list_element
*dump_cmdlist
;
161 struct cmd_list_element
*append_cmdlist
;
162 struct cmd_list_element
*srec_cmdlist
;
163 struct cmd_list_element
*ihex_cmdlist
;
164 struct cmd_list_element
*tekhex_cmdlist
;
165 struct cmd_list_element
*binary_dump_cmdlist
;
166 struct cmd_list_element
*binary_append_cmdlist
;
169 dump_command (char *cmd
, int from_tty
)
171 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
172 help_list (dump_cmdlist
, "dump ", -1, gdb_stdout
);
176 append_command (char *cmd
, int from_tty
)
178 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
179 help_list (dump_cmdlist
, "append ", -1, gdb_stdout
);
183 dump_binary_file (const char *filename
, const char *mode
,
184 const bfd_byte
*buf
, int len
)
189 file
= fopen_with_cleanup (filename
, mode
);
190 status
= fwrite (buf
, len
, 1, file
);
192 perror_with_name (filename
);
196 dump_bfd_file (const char *filename
, const char *mode
,
197 const char *target
, CORE_ADDR vaddr
,
198 const bfd_byte
*buf
, int len
)
203 obfd
= bfd_openw_with_cleanup (filename
, target
, mode
);
204 osection
= bfd_make_section_anyway (obfd
, ".newsec");
205 bfd_set_section_size (obfd
, osection
, len
);
206 bfd_set_section_vma (obfd
, osection
, vaddr
);
207 bfd_set_section_alignment (obfd
, osection
, 0);
208 bfd_set_section_flags (obfd
, osection
, (SEC_HAS_CONTENTS
211 osection
->entsize
= 0;
212 bfd_set_section_contents (obfd
, osection
, buf
, 0, len
);
216 dump_memory_to_file (char *cmd
, char *mode
, char *file_format
)
218 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
228 filename
= scan_filename_with_cleanup (&cmd
, NULL
);
230 /* Find the low address. */
231 if (cmd
== NULL
|| *cmd
== '\0')
232 error (_("Missing start address."));
233 lo_exp
= scan_expression_with_cleanup (&cmd
, NULL
);
235 /* Find the second address - rest of line. */
236 if (cmd
== NULL
|| *cmd
== '\0')
237 error (_("Missing stop address."));
240 lo
= parse_and_eval_address (lo_exp
);
241 hi
= parse_and_eval_address (hi_exp
);
243 error (_("Invalid memory address range (start >= end)."));
246 /* FIXME: Should use read_memory_partial() and a magic blocking
248 buf
= xmalloc (count
);
249 make_cleanup (xfree
, buf
);
250 read_memory (lo
, buf
, count
);
252 /* Have everything. Open/write the data. */
253 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
255 dump_binary_file (filename
, mode
, buf
, count
);
259 dump_bfd_file (filename
, mode
, file_format
, lo
, buf
, count
);
262 do_cleanups (old_cleanups
);
266 dump_memory_command (char *cmd
, char *mode
)
268 dump_memory_to_file (cmd
, mode
, "binary");
272 dump_value_to_file (char *cmd
, char *mode
, char *file_format
)
274 struct cleanup
*old_cleanups
= make_cleanup (null_cleanup
, NULL
);
279 filename
= scan_filename_with_cleanup (&cmd
, NULL
);
281 /* Find the value. */
282 if (cmd
== NULL
|| *cmd
== '\0')
283 error (_("No value to %s."), *mode
== 'a' ? "append" : "dump");
284 val
= parse_and_eval (cmd
);
286 error (_("Invalid expression."));
288 /* Have everything. Open/write the data. */
289 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
291 dump_binary_file (filename
, mode
, value_contents (val
),
292 TYPE_LENGTH (value_type (val
)));
298 if (VALUE_LVAL (val
))
300 vaddr
= value_address (val
);
305 warning (_("value is not an lval: address assumed to be zero"));
308 dump_bfd_file (filename
, mode
, file_format
, vaddr
,
309 value_contents (val
),
310 TYPE_LENGTH (value_type (val
)));
313 do_cleanups (old_cleanups
);
317 dump_value_command (char *cmd
, char *mode
)
319 dump_value_to_file (cmd
, mode
, "binary");
323 dump_srec_memory (char *args
, int from_tty
)
325 dump_memory_to_file (args
, FOPEN_WB
, "srec");
329 dump_srec_value (char *args
, int from_tty
)
331 dump_value_to_file (args
, FOPEN_WB
, "srec");
335 dump_ihex_memory (char *args
, int from_tty
)
337 dump_memory_to_file (args
, FOPEN_WB
, "ihex");
341 dump_ihex_value (char *args
, int from_tty
)
343 dump_value_to_file (args
, FOPEN_WB
, "ihex");
347 dump_tekhex_memory (char *args
, int from_tty
)
349 dump_memory_to_file (args
, FOPEN_WB
, "tekhex");
353 dump_tekhex_value (char *args
, int from_tty
)
355 dump_value_to_file (args
, FOPEN_WB
, "tekhex");
359 dump_binary_memory (char *args
, int from_tty
)
361 dump_memory_to_file (args
, FOPEN_WB
, "binary");
365 dump_binary_value (char *args
, int from_tty
)
367 dump_value_to_file (args
, FOPEN_WB
, "binary");
371 append_binary_memory (char *args
, int from_tty
)
373 dump_memory_to_file (args
, FOPEN_AB
, "binary");
377 append_binary_value (char *args
, int from_tty
)
379 dump_value_to_file (args
, FOPEN_AB
, "binary");
384 void (*func
) (char *cmd
, char *mode
);
389 call_dump_func (struct cmd_list_element
*c
, char *args
, int from_tty
)
391 struct dump_context
*d
= get_cmd_context (c
);
392 d
->func (args
, d
->mode
);
396 add_dump_command (char *name
, void (*func
) (char *args
, char *mode
),
400 struct cmd_list_element
*c
;
401 struct dump_context
*d
;
403 c
= add_cmd (name
, all_commands
, NULL
, descr
, &dump_cmdlist
);
404 c
->completer
= filename_completer
;
405 d
= XMALLOC (struct dump_context
);
408 set_cmd_context (c
, d
);
409 c
->func
= call_dump_func
;
411 c
= add_cmd (name
, all_commands
, NULL
, descr
, &append_cmdlist
);
412 c
->completer
= filename_completer
;
413 d
= XMALLOC (struct dump_context
);
416 set_cmd_context (c
, d
);
417 c
->func
= call_dump_func
;
419 /* Replace "Dump " at start of docstring with "Append " (borrowed
420 from [deleted] deprecated_add_show_from_set). */
421 if ( c
->doc
[0] == 'W'
427 c
->doc
= concat ("Append ", c
->doc
+ 6, (char *)NULL
);
430 /* Opaque data for restore_section_callback. */
431 struct callback_data
{
432 CORE_ADDR load_offset
;
433 CORE_ADDR load_start
;
437 /* Function: restore_section_callback.
439 Callback function for bfd_map_over_sections.
440 Selectively loads the sections into memory. */
443 restore_section_callback (bfd
*ibfd
, asection
*isec
, void *args
)
445 struct callback_data
*data
= args
;
446 bfd_vma sec_start
= bfd_section_vma (ibfd
, isec
);
447 bfd_size_type size
= bfd_section_size (ibfd
, isec
);
448 bfd_vma sec_end
= sec_start
+ size
;
449 bfd_size_type sec_offset
= 0;
450 bfd_size_type sec_load_count
= size
;
451 struct cleanup
*old_chain
;
455 /* Ignore non-loadable sections, eg. from elf files. */
456 if (!(bfd_get_section_flags (ibfd
, isec
) & SEC_LOAD
))
459 /* Does the section overlap with the desired restore range? */
460 if (sec_end
<= data
->load_start
461 || (data
->load_end
> 0 && sec_start
>= data
->load_end
))
463 /* No, no useable data in this section. */
464 printf_filtered (_("skipping section %s...\n"),
465 bfd_section_name (ibfd
, isec
));
469 /* Compare section address range with user-requested
470 address range (if any). Compute where the actual
471 transfer should start and end. */
472 if (sec_start
< data
->load_start
)
473 sec_offset
= data
->load_start
- sec_start
;
474 /* Size of a partial transfer: */
475 sec_load_count
-= sec_offset
;
476 if (data
->load_end
> 0 && sec_end
> data
->load_end
)
477 sec_load_count
-= sec_end
- data
->load_end
;
480 buf
= xmalloc (size
);
481 old_chain
= make_cleanup (xfree
, buf
);
482 if (!bfd_get_section_contents (ibfd
, isec
, buf
, 0, size
))
483 error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd
),
484 bfd_errmsg (bfd_get_error ()));
486 printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
487 bfd_section_name (ibfd
, isec
),
488 (unsigned long) sec_start
,
489 (unsigned long) sec_end
);
491 if (data
->load_offset
!= 0 || data
->load_start
!= 0 || data
->load_end
!= 0)
492 printf_filtered (" into memory (%s to %s)\n",
493 paddress (target_gdbarch
,
494 (unsigned long) sec_start
495 + sec_offset
+ data
->load_offset
),
496 paddress (target_gdbarch
,
497 (unsigned long) sec_start
+ sec_offset
498 + data
->load_offset
+ sec_load_count
));
500 puts_filtered ("\n");
502 /* Write the data. */
503 ret
= target_write_memory (sec_start
+ sec_offset
+ data
->load_offset
,
504 buf
+ sec_offset
, sec_load_count
);
506 warning (_("restore: memory write failed (%s)."), safe_strerror (ret
));
507 do_cleanups (old_chain
);
512 restore_binary_file (char *filename
, struct callback_data
*data
)
514 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. */