1 /* Dump-to-file commands, for GDB, the GNU debugger.
3 Copyright (C) 2002-2020 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/tilde.h"
31 #include "cli/cli-utils.h"
33 #include "gdbsupport/filestuff.h"
34 #include "gdbsupport/byte-vector.h"
37 static gdb::unique_xmalloc_ptr
<char>
38 scan_expression (const char **cmd
, const char *def
)
40 if ((*cmd
) == NULL
|| (**cmd
) == '\0')
41 return make_unique_xstrdup (def
);
47 end
= (*cmd
) + strcspn (*cmd
, " \t");
48 exp
= savestring ((*cmd
), end
- (*cmd
));
49 (*cmd
) = skip_spaces (end
);
50 return gdb::unique_xmalloc_ptr
<char> (exp
);
55 static gdb::unique_xmalloc_ptr
<char>
56 scan_filename (const char **cmd
, const char *defname
)
58 gdb::unique_xmalloc_ptr
<char> filename
;
60 /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
66 error (_("Missing filename."));
67 filename
.reset (xstrdup (defname
));
71 /* FIXME: should parse a possibly quoted string. */
74 (*cmd
) = skip_spaces (*cmd
);
75 end
= *cmd
+ strcspn (*cmd
, " \t");
76 filename
.reset (savestring ((*cmd
), end
- (*cmd
)));
77 (*cmd
) = skip_spaces (end
);
79 gdb_assert (filename
!= NULL
);
81 return gdb::unique_xmalloc_ptr
<char> (tilde_expand (filename
.get ()));
84 static gdb_bfd_ref_ptr
85 bfd_openr_or_error (const char *filename
, const char *target
)
87 gdb_bfd_ref_ptr
ibfd (gdb_bfd_openr (filename
, target
));
89 error (_("Failed to open %s: %s."), filename
,
90 bfd_errmsg (bfd_get_error ()));
92 if (!bfd_check_format (ibfd
.get (), bfd_object
))
93 error (_("'%s' is not a recognized file format."), filename
);
98 static gdb_bfd_ref_ptr
99 bfd_openw_or_error (const char *filename
, const char *target
, const char *mode
)
101 gdb_bfd_ref_ptr obfd
;
103 if (*mode
== 'w') /* Write: create new file */
105 obfd
= gdb_bfd_openw (filename
, target
);
107 error (_("Failed to open %s: %s."), filename
,
108 bfd_errmsg (bfd_get_error ()));
109 if (!bfd_set_format (obfd
.get (), bfd_object
))
110 error (_("bfd_openw_or_error: %s."), bfd_errmsg (bfd_get_error ()));
112 else if (*mode
== 'a') /* Append to existing file. */
113 { /* FIXME -- doesn't work... */
114 error (_("bfd_openw does not work with append."));
117 error (_("bfd_openw_or_error: unknown mode %s."), mode
);
122 static struct cmd_list_element
*dump_cmdlist
;
123 static struct cmd_list_element
*append_cmdlist
;
124 static struct cmd_list_element
*srec_cmdlist
;
125 static struct cmd_list_element
*ihex_cmdlist
;
126 static struct cmd_list_element
*verilog_cmdlist
;
127 static struct cmd_list_element
*tekhex_cmdlist
;
128 static struct cmd_list_element
*binary_dump_cmdlist
;
129 static struct cmd_list_element
*binary_append_cmdlist
;
132 dump_command (const char *cmd
, int from_tty
)
134 printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
135 help_list (dump_cmdlist
, "dump ", all_commands
, gdb_stdout
);
139 append_command (const char *cmd
, int from_tty
)
141 printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
142 help_list (dump_cmdlist
, "append ", all_commands
, gdb_stdout
);
146 dump_binary_file (const char *filename
, const char *mode
,
147 const bfd_byte
*buf
, ULONGEST len
)
151 gdb_file_up file
= gdb_fopen_cloexec (filename
, mode
);
152 status
= fwrite (buf
, len
, 1, file
.get ());
154 perror_with_name (filename
);
158 dump_bfd_file (const char *filename
, const char *mode
,
159 const char *target
, CORE_ADDR vaddr
,
160 const bfd_byte
*buf
, ULONGEST len
)
164 gdb_bfd_ref_ptr
obfd (bfd_openw_or_error (filename
, target
, mode
));
165 osection
= bfd_make_section_anyway (obfd
.get (), ".newsec");
166 bfd_set_section_size (osection
, len
);
167 bfd_set_section_vma (osection
, vaddr
);
168 bfd_set_section_alignment (osection
, 0);
169 bfd_set_section_flags (osection
, (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
));
170 osection
->entsize
= 0;
171 if (!bfd_set_section_contents (obfd
.get (), osection
, buf
, 0, len
))
172 warning (_("writing dump file '%s' (%s)"), filename
,
173 bfd_errmsg (bfd_get_error ()));
177 dump_memory_to_file (const char *cmd
, const char *mode
, const char *file_format
)
185 gdb::unique_xmalloc_ptr
<char> filename
= scan_filename (&cmd
, NULL
);
187 /* Find the low address. */
188 if (cmd
== NULL
|| *cmd
== '\0')
189 error (_("Missing start address."));
190 gdb::unique_xmalloc_ptr
<char> lo_exp
= scan_expression (&cmd
, NULL
);
192 /* Find the second address - rest of line. */
193 if (cmd
== NULL
|| *cmd
== '\0')
194 error (_("Missing stop address."));
197 lo
= parse_and_eval_address (lo_exp
.get ());
198 hi
= parse_and_eval_address (hi_exp
);
200 error (_("Invalid memory address range (start >= end)."));
203 /* FIXME: Should use read_memory_partial() and a magic blocking
205 gdb::byte_vector
buf (count
);
206 read_memory (lo
, buf
.data (), count
);
208 /* Have everything. Open/write the data. */
209 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
210 dump_binary_file (filename
.get (), mode
, buf
.data (), count
);
212 dump_bfd_file (filename
.get (), mode
, file_format
, lo
, buf
.data (), count
);
216 dump_memory_command (const char *cmd
, const char *mode
)
218 dump_memory_to_file (cmd
, mode
, "binary");
222 dump_value_to_file (const char *cmd
, const char *mode
, const char *file_format
)
227 gdb::unique_xmalloc_ptr
<char> filename
= scan_filename (&cmd
, NULL
);
229 /* Find the value. */
230 if (cmd
== NULL
|| *cmd
== '\0')
231 error (_("No value to %s."), *mode
== 'a' ? "append" : "dump");
232 val
= parse_and_eval (cmd
);
234 error (_("Invalid expression."));
236 /* Have everything. Open/write the data. */
237 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
238 dump_binary_file (filename
.get (), mode
, value_contents (val
),
239 TYPE_LENGTH (value_type (val
)));
244 if (VALUE_LVAL (val
))
246 vaddr
= value_address (val
);
251 warning (_("value is not an lval: address assumed to be zero"));
254 dump_bfd_file (filename
.get (), mode
, file_format
, vaddr
,
255 value_contents (val
),
256 TYPE_LENGTH (value_type (val
)));
261 dump_value_command (const char *cmd
, const char *mode
)
263 dump_value_to_file (cmd
, mode
, "binary");
267 dump_srec_memory (const char *args
, int from_tty
)
269 dump_memory_to_file (args
, FOPEN_WB
, "srec");
273 dump_srec_value (const char *args
, int from_tty
)
275 dump_value_to_file (args
, FOPEN_WB
, "srec");
279 dump_ihex_memory (const char *args
, int from_tty
)
281 dump_memory_to_file (args
, FOPEN_WB
, "ihex");
285 dump_ihex_value (const char *args
, int from_tty
)
287 dump_value_to_file (args
, FOPEN_WB
, "ihex");
291 dump_verilog_memory (const char *args
, int from_tty
)
293 dump_memory_to_file (args
, FOPEN_WB
, "verilog");
297 dump_verilog_value (const char *args
, int from_tty
)
299 dump_value_to_file (args
, FOPEN_WB
, "verilog");
303 dump_tekhex_memory (const char *args
, int from_tty
)
305 dump_memory_to_file (args
, FOPEN_WB
, "tekhex");
309 dump_tekhex_value (const char *args
, int from_tty
)
311 dump_value_to_file (args
, FOPEN_WB
, "tekhex");
315 dump_binary_memory (const char *args
, int from_tty
)
317 dump_memory_to_file (args
, FOPEN_WB
, "binary");
321 dump_binary_value (const char *args
, int from_tty
)
323 dump_value_to_file (args
, FOPEN_WB
, "binary");
327 append_binary_memory (const char *args
, int from_tty
)
329 dump_memory_to_file (args
, FOPEN_AB
, "binary");
333 append_binary_value (const char *args
, int from_tty
)
335 dump_value_to_file (args
, FOPEN_AB
, "binary");
340 void (*func
) (const char *cmd
, const char *mode
);
345 call_dump_func (struct cmd_list_element
*c
, const char *args
, int from_tty
)
347 struct dump_context
*d
= (struct dump_context
*) get_cmd_context (c
);
349 d
->func (args
, d
->mode
);
353 add_dump_command (const char *name
,
354 void (*func
) (const char *args
, const char *mode
),
358 struct cmd_list_element
*c
;
359 struct dump_context
*d
;
361 c
= add_cmd (name
, all_commands
, descr
, &dump_cmdlist
);
362 c
->completer
= filename_completer
;
363 d
= XNEW (struct dump_context
);
366 set_cmd_context (c
, d
);
367 c
->func
= call_dump_func
;
369 c
= add_cmd (name
, all_commands
, descr
, &append_cmdlist
);
370 c
->completer
= filename_completer
;
371 d
= XNEW (struct dump_context
);
374 set_cmd_context (c
, d
);
375 c
->func
= call_dump_func
;
377 /* Replace "Dump " at start of docstring with "Append " (borrowed
378 from [deleted] deprecated_add_show_from_set). */
379 if ( c
->doc
[0] == 'W'
385 c
->doc
= concat ("Append ", c
->doc
+ 6, (char *)NULL
);
388 /* Opaque data for restore_section_callback. */
389 struct callback_data
{
390 CORE_ADDR load_offset
;
391 CORE_ADDR load_start
;
395 /* Function: restore_section_callback.
397 Callback function for bfd_map_over_sections.
398 Selectively loads the sections into memory. */
401 restore_section_callback (bfd
*ibfd
, asection
*isec
, void *args
)
403 struct callback_data
*data
= (struct callback_data
*) args
;
404 bfd_vma sec_start
= bfd_section_vma (isec
);
405 bfd_size_type size
= bfd_section_size (isec
);
406 bfd_vma sec_end
= sec_start
+ size
;
407 bfd_size_type sec_offset
= 0;
408 bfd_size_type sec_load_count
= size
;
411 /* Ignore non-loadable sections, eg. from elf files. */
412 if (!(bfd_section_flags (isec
) & SEC_LOAD
))
415 /* Does the section overlap with the desired restore range? */
416 if (sec_end
<= data
->load_start
417 || (data
->load_end
> 0 && sec_start
>= data
->load_end
))
419 /* No, no useable data in this section. */
420 printf_filtered (_("skipping section %s...\n"),
421 bfd_section_name (isec
));
425 /* Compare section address range with user-requested
426 address range (if any). Compute where the actual
427 transfer should start and end. */
428 if (sec_start
< data
->load_start
)
429 sec_offset
= data
->load_start
- sec_start
;
430 /* Size of a partial transfer. */
431 sec_load_count
-= sec_offset
;
432 if (data
->load_end
> 0 && sec_end
> data
->load_end
)
433 sec_load_count
-= sec_end
- data
->load_end
;
436 gdb::byte_vector
buf (size
);
437 if (!bfd_get_section_contents (ibfd
, isec
, buf
.data (), 0, size
))
438 error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd
),
439 bfd_errmsg (bfd_get_error ()));
441 printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
442 bfd_section_name (isec
),
443 (unsigned long) sec_start
,
444 (unsigned long) sec_end
);
446 if (data
->load_offset
!= 0 || data
->load_start
!= 0 || data
->load_end
!= 0)
447 printf_filtered (" into memory (%s to %s)\n",
448 paddress (target_gdbarch (),
449 (unsigned long) sec_start
450 + sec_offset
+ data
->load_offset
),
451 paddress (target_gdbarch (),
452 (unsigned long) sec_start
+ sec_offset
453 + data
->load_offset
+ sec_load_count
));
455 puts_filtered ("\n");
457 /* Write the data. */
458 ret
= target_write_memory (sec_start
+ sec_offset
+ data
->load_offset
,
459 &buf
[sec_offset
], sec_load_count
);
461 warning (_("restore: memory write failed (%s)."), safe_strerror (ret
));
465 restore_binary_file (const char *filename
, struct callback_data
*data
)
467 gdb_file_up file
= gdb_fopen_cloexec (filename
, FOPEN_RB
);
471 error (_("Failed to open %s: %s"), filename
, safe_strerror (errno
));
473 /* Get the file size for reading. */
474 if (fseek (file
.get (), 0, SEEK_END
) == 0)
476 len
= ftell (file
.get ());
478 perror_with_name (filename
);
481 perror_with_name (filename
);
483 if (len
<= data
->load_start
)
484 error (_("Start address is greater than length of binary file %s."),
487 /* Chop off "len" if it exceeds the requested load_end addr. */
488 if (data
->load_end
!= 0 && data
->load_end
< len
)
489 len
= data
->load_end
;
490 /* Chop off "len" if the requested load_start addr skips some bytes. */
491 if (data
->load_start
> 0)
492 len
-= data
->load_start
;
495 ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
497 (unsigned long) (data
->load_start
+ data
->load_offset
),
498 (unsigned long) (data
->load_start
+ data
->load_offset
+ len
));
500 /* Now set the file pos to the requested load start pos. */
501 if (fseek (file
.get (), data
->load_start
, SEEK_SET
) != 0)
502 perror_with_name (filename
);
504 /* Now allocate a buffer and read the file contents. */
505 gdb::byte_vector
buf (len
);
506 if (fread (buf
.data (), 1, len
, file
.get ()) != len
)
507 perror_with_name (filename
);
509 /* Now write the buffer into target memory. */
510 len
= target_write_memory (data
->load_start
+ data
->load_offset
,
513 warning (_("restore: memory write failed (%s)."), safe_strerror (len
));
517 restore_command (const char *args
, int from_tty
)
519 struct callback_data data
;
522 if (!target_has_execution
)
525 data
.load_offset
= 0;
529 /* Parse the input arguments. First is filename (required). */
530 gdb::unique_xmalloc_ptr
<char> filename
= scan_filename (&args
, NULL
);
531 if (args
!= NULL
&& *args
!= '\0')
533 static const char binary_string
[] = "binary";
535 /* Look for optional "binary" flag. */
536 if (startswith (args
, binary_string
))
539 args
+= strlen (binary_string
);
540 args
= skip_spaces (args
);
542 /* Parse offset (optional). */
543 if (args
!= NULL
&& *args
!= '\0')
544 data
.load_offset
= binary_flag
?
545 parse_and_eval_address (scan_expression (&args
, NULL
).get ()) :
546 parse_and_eval_long (scan_expression (&args
, NULL
).get ());
547 if (args
!= NULL
&& *args
!= '\0')
549 /* Parse start address (optional). */
551 parse_and_eval_long (scan_expression (&args
, NULL
).get ());
552 if (args
!= NULL
&& *args
!= '\0')
554 /* Parse end address (optional). */
555 data
.load_end
= parse_and_eval_long (args
);
556 if (data
.load_end
<= data
.load_start
)
557 error (_("Start must be less than end."));
563 printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
564 filename
.get (), (unsigned long) data
.load_offset
,
565 (unsigned long) data
.load_start
,
566 (unsigned long) data
.load_end
);
570 restore_binary_file (filename
.get (), &data
);
574 /* Open the file for loading. */
575 gdb_bfd_ref_ptr
ibfd (bfd_openr_or_error (filename
.get (), NULL
));
577 /* Process the sections. */
578 bfd_map_over_sections (ibfd
.get (), restore_section_callback
, &data
);
583 srec_dump_command (const char *cmd
, int from_tty
)
585 printf_unfiltered (_("\"dump srec\" must be followed by a subcommand.\n"));
586 help_list (srec_cmdlist
, "dump srec ", all_commands
, gdb_stdout
);
590 ihex_dump_command (const char *cmd
, int from_tty
)
592 printf_unfiltered (_("\"dump ihex\" must be followed by a subcommand.\n"));
593 help_list (ihex_cmdlist
, "dump ihex ", all_commands
, gdb_stdout
);
597 verilog_dump_command (const char *cmd
, int from_tty
)
599 printf_unfiltered (_("\"dump verilog\" must be followed by a subcommand.\n"));
600 help_list (verilog_cmdlist
, "dump verilog ", all_commands
, gdb_stdout
);
604 tekhex_dump_command (const char *cmd
, int from_tty
)
606 printf_unfiltered (_("\"dump tekhex\" must be followed by a subcommand.\n"));
607 help_list (tekhex_cmdlist
, "dump tekhex ", all_commands
, gdb_stdout
);
611 binary_dump_command (const char *cmd
, int from_tty
)
613 printf_unfiltered (_("\"dump binary\" must be followed by a subcommand.\n"));
614 help_list (binary_dump_cmdlist
, "dump binary ", all_commands
, gdb_stdout
);
618 binary_append_command (const char *cmd
, int from_tty
)
620 printf_unfiltered (_("\"append binary\" must be followed by a subcommand.\n"));
621 help_list (binary_append_cmdlist
, "append binary ", all_commands
,
626 _initialize_cli_dump (void)
628 struct cmd_list_element
*c
;
630 add_prefix_cmd ("dump", class_vars
, dump_command
,
631 _("Dump target code/data to a local file."),
632 &dump_cmdlist
, "dump ",
635 add_prefix_cmd ("append", class_vars
, append_command
,
636 _("Append target code/data to a local file."),
637 &append_cmdlist
, "append ",
641 add_dump_command ("memory", dump_memory_command
, "\
642 Write contents of memory to a raw binary file.\n\
643 Arguments are FILE START STOP. Writes the contents of memory within the\n\
644 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
646 add_dump_command ("value", dump_value_command
, "\
647 Write the value of an expression to a raw binary file.\n\
648 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
649 the specified FILE in raw target ordered bytes.");
651 add_prefix_cmd ("srec", all_commands
, srec_dump_command
,
652 _("Write target code/data to an srec file."),
653 &srec_cmdlist
, "dump srec ",
657 add_prefix_cmd ("ihex", all_commands
, ihex_dump_command
,
658 _("Write target code/data to an intel hex file."),
659 &ihex_cmdlist
, "dump ihex ",
663 add_prefix_cmd ("verilog", all_commands
, verilog_dump_command
,
664 _("Write target code/data to a verilog hex file."),
665 &verilog_cmdlist
, "dump verilog ",
669 add_prefix_cmd ("tekhex", all_commands
, tekhex_dump_command
,
670 _("Write target code/data to a tekhex file."),
671 &tekhex_cmdlist
, "dump tekhex ",
675 add_prefix_cmd ("binary", all_commands
, binary_dump_command
,
676 _("Write target code/data to a raw binary file."),
677 &binary_dump_cmdlist
, "dump binary ",
681 add_prefix_cmd ("binary", all_commands
, binary_append_command
,
682 _("Append target code/data to a raw binary file."),
683 &binary_append_cmdlist
, "append binary ",
687 add_cmd ("memory", all_commands
, dump_srec_memory
, _("\
688 Write contents of memory to an srec file.\n\
689 Arguments are FILE START STOP. Writes the contents of memory\n\
690 within the range [START .. STOP) to the specified FILE in srec format."),
693 add_cmd ("value", all_commands
, dump_srec_value
, _("\
694 Write the value of an expression to an srec file.\n\
695 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
696 to the specified FILE in srec format."),
699 add_cmd ("memory", all_commands
, dump_ihex_memory
, _("\
700 Write contents of memory to an ihex file.\n\
701 Arguments are FILE START STOP. Writes the contents of memory within\n\
702 the range [START .. STOP) to the specified FILE in intel hex format."),
705 add_cmd ("value", all_commands
, dump_ihex_value
, _("\
706 Write the value of an expression to an ihex file.\n\
707 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
708 to the specified FILE in intel hex format."),
711 add_cmd ("memory", all_commands
, dump_verilog_memory
, _("\
712 Write contents of memory to a verilog hex file.\n\
713 Arguments are FILE START STOP. Writes the contents of memory within\n\
714 the range [START .. STOP) to the specified FILE in verilog hex format."),
717 add_cmd ("value", all_commands
, dump_verilog_value
, _("\
718 Write the value of an expression to a verilog hex file.\n\
719 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
720 to the specified FILE in verilog hex format."),
723 add_cmd ("memory", all_commands
, dump_tekhex_memory
, _("\
724 Write contents of memory to a tekhex file.\n\
725 Arguments are FILE START STOP. Writes the contents of memory\n\
726 within the range [START .. STOP) to the specified FILE in tekhex format."),
729 add_cmd ("value", all_commands
, dump_tekhex_value
, _("\
730 Write the value of an expression to a tekhex file.\n\
731 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
732 to the specified FILE in tekhex format."),
735 add_cmd ("memory", all_commands
, dump_binary_memory
, _("\
736 Write contents of memory to a raw binary file.\n\
737 Arguments are FILE START STOP. Writes the contents of memory\n\
738 within the range [START .. STOP) to the specified FILE in binary format."),
739 &binary_dump_cmdlist
);
741 add_cmd ("value", all_commands
, dump_binary_value
, _("\
742 Write the value of an expression to a raw binary file.\n\
743 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
744 to the specified FILE in raw target ordered bytes."),
745 &binary_dump_cmdlist
);
747 add_cmd ("memory", all_commands
, append_binary_memory
, _("\
748 Append contents of memory to a raw binary file.\n\
749 Arguments are FILE START STOP. Writes the contents of memory within the\n\
750 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
751 &binary_append_cmdlist
);
753 add_cmd ("value", all_commands
, append_binary_value
, _("\
754 Append the value of an expression to a raw binary file.\n\
755 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
756 to the specified FILE in raw target ordered bytes."),
757 &binary_append_cmdlist
);
759 c
= add_com ("restore", class_vars
, restore_command
, _("\
760 Restore the contents of FILE to target memory.\n\
761 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
762 OFFSET will be added to the base address of the file (default zero).\n\
763 If START and END are given, only the file contents within that range\n\
764 (file relative) will be restored to target memory."));
765 c
->completer
= filename_completer
;
766 /* FIXME: completers for other commands. */