1 /* Dump-to-file commands, for GDB, the GNU debugger.
3 Copyright (C) 2002-2019 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/readline.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 (obfd
.get (), osection
, len
);
167 bfd_set_section_vma (obfd
.get (), osection
, vaddr
);
168 bfd_set_section_alignment (obfd
.get (), osection
, 0);
169 bfd_set_section_flags (obfd
.get (), osection
, (SEC_HAS_CONTENTS
172 osection
->entsize
= 0;
173 if (!bfd_set_section_contents (obfd
.get (), osection
, buf
, 0, len
))
174 warning (_("writing dump file '%s' (%s)"), filename
,
175 bfd_errmsg (bfd_get_error ()));
179 dump_memory_to_file (const char *cmd
, const char *mode
, const char *file_format
)
187 gdb::unique_xmalloc_ptr
<char> filename
= scan_filename (&cmd
, NULL
);
189 /* Find the low address. */
190 if (cmd
== NULL
|| *cmd
== '\0')
191 error (_("Missing start address."));
192 gdb::unique_xmalloc_ptr
<char> lo_exp
= scan_expression (&cmd
, NULL
);
194 /* Find the second address - rest of line. */
195 if (cmd
== NULL
|| *cmd
== '\0')
196 error (_("Missing stop address."));
199 lo
= parse_and_eval_address (lo_exp
.get ());
200 hi
= parse_and_eval_address (hi_exp
);
202 error (_("Invalid memory address range (start >= end)."));
205 /* FIXME: Should use read_memory_partial() and a magic blocking
207 gdb::byte_vector
buf (count
);
208 read_memory (lo
, buf
.data (), count
);
210 /* Have everything. Open/write the data. */
211 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
212 dump_binary_file (filename
.get (), mode
, buf
.data (), count
);
214 dump_bfd_file (filename
.get (), mode
, file_format
, lo
, buf
.data (), count
);
218 dump_memory_command (const char *cmd
, const char *mode
)
220 dump_memory_to_file (cmd
, mode
, "binary");
224 dump_value_to_file (const char *cmd
, const char *mode
, const char *file_format
)
229 gdb::unique_xmalloc_ptr
<char> filename
= scan_filename (&cmd
, NULL
);
231 /* Find the value. */
232 if (cmd
== NULL
|| *cmd
== '\0')
233 error (_("No value to %s."), *mode
== 'a' ? "append" : "dump");
234 val
= parse_and_eval (cmd
);
236 error (_("Invalid expression."));
238 /* Have everything. Open/write the data. */
239 if (file_format
== NULL
|| strcmp (file_format
, "binary") == 0)
240 dump_binary_file (filename
.get (), mode
, value_contents (val
),
241 TYPE_LENGTH (value_type (val
)));
246 if (VALUE_LVAL (val
))
248 vaddr
= value_address (val
);
253 warning (_("value is not an lval: address assumed to be zero"));
256 dump_bfd_file (filename
.get (), mode
, file_format
, vaddr
,
257 value_contents (val
),
258 TYPE_LENGTH (value_type (val
)));
263 dump_value_command (const char *cmd
, const char *mode
)
265 dump_value_to_file (cmd
, mode
, "binary");
269 dump_srec_memory (const char *args
, int from_tty
)
271 dump_memory_to_file (args
, FOPEN_WB
, "srec");
275 dump_srec_value (const char *args
, int from_tty
)
277 dump_value_to_file (args
, FOPEN_WB
, "srec");
281 dump_ihex_memory (const char *args
, int from_tty
)
283 dump_memory_to_file (args
, FOPEN_WB
, "ihex");
287 dump_ihex_value (const char *args
, int from_tty
)
289 dump_value_to_file (args
, FOPEN_WB
, "ihex");
293 dump_verilog_memory (const char *args
, int from_tty
)
295 dump_memory_to_file (args
, FOPEN_WB
, "verilog");
299 dump_verilog_value (const char *args
, int from_tty
)
301 dump_value_to_file (args
, FOPEN_WB
, "verilog");
305 dump_tekhex_memory (const char *args
, int from_tty
)
307 dump_memory_to_file (args
, FOPEN_WB
, "tekhex");
311 dump_tekhex_value (const char *args
, int from_tty
)
313 dump_value_to_file (args
, FOPEN_WB
, "tekhex");
317 dump_binary_memory (const char *args
, int from_tty
)
319 dump_memory_to_file (args
, FOPEN_WB
, "binary");
323 dump_binary_value (const char *args
, int from_tty
)
325 dump_value_to_file (args
, FOPEN_WB
, "binary");
329 append_binary_memory (const char *args
, int from_tty
)
331 dump_memory_to_file (args
, FOPEN_AB
, "binary");
335 append_binary_value (const char *args
, int from_tty
)
337 dump_value_to_file (args
, FOPEN_AB
, "binary");
342 void (*func
) (const char *cmd
, const char *mode
);
347 call_dump_func (struct cmd_list_element
*c
, const char *args
, int from_tty
)
349 struct dump_context
*d
= (struct dump_context
*) get_cmd_context (c
);
351 d
->func (args
, d
->mode
);
355 add_dump_command (const char *name
,
356 void (*func
) (const char *args
, const char *mode
),
360 struct cmd_list_element
*c
;
361 struct dump_context
*d
;
363 c
= add_cmd (name
, all_commands
, descr
, &dump_cmdlist
);
364 c
->completer
= filename_completer
;
365 d
= XNEW (struct dump_context
);
368 set_cmd_context (c
, d
);
369 c
->func
= call_dump_func
;
371 c
= add_cmd (name
, all_commands
, descr
, &append_cmdlist
);
372 c
->completer
= filename_completer
;
373 d
= XNEW (struct dump_context
);
376 set_cmd_context (c
, d
);
377 c
->func
= call_dump_func
;
379 /* Replace "Dump " at start of docstring with "Append " (borrowed
380 from [deleted] deprecated_add_show_from_set). */
381 if ( c
->doc
[0] == 'W'
387 c
->doc
= concat ("Append ", c
->doc
+ 6, (char *)NULL
);
390 /* Opaque data for restore_section_callback. */
391 struct callback_data
{
392 CORE_ADDR load_offset
;
393 CORE_ADDR load_start
;
397 /* Function: restore_section_callback.
399 Callback function for bfd_map_over_sections.
400 Selectively loads the sections into memory. */
403 restore_section_callback (bfd
*ibfd
, asection
*isec
, void *args
)
405 struct callback_data
*data
= (struct callback_data
*) args
;
406 bfd_vma sec_start
= bfd_section_vma (ibfd
, isec
);
407 bfd_size_type size
= bfd_section_size (ibfd
, isec
);
408 bfd_vma sec_end
= sec_start
+ size
;
409 bfd_size_type sec_offset
= 0;
410 bfd_size_type sec_load_count
= size
;
413 /* Ignore non-loadable sections, eg. from elf files. */
414 if (!(bfd_get_section_flags (ibfd
, isec
) & SEC_LOAD
))
417 /* Does the section overlap with the desired restore range? */
418 if (sec_end
<= data
->load_start
419 || (data
->load_end
> 0 && sec_start
>= data
->load_end
))
421 /* No, no useable data in this section. */
422 printf_filtered (_("skipping section %s...\n"),
423 bfd_section_name (ibfd
, isec
));
427 /* Compare section address range with user-requested
428 address range (if any). Compute where the actual
429 transfer should start and end. */
430 if (sec_start
< data
->load_start
)
431 sec_offset
= data
->load_start
- sec_start
;
432 /* Size of a partial transfer. */
433 sec_load_count
-= sec_offset
;
434 if (data
->load_end
> 0 && sec_end
> data
->load_end
)
435 sec_load_count
-= sec_end
- data
->load_end
;
438 gdb::byte_vector
buf (size
);
439 if (!bfd_get_section_contents (ibfd
, isec
, buf
.data (), 0, size
))
440 error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd
),
441 bfd_errmsg (bfd_get_error ()));
443 printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
444 bfd_section_name (ibfd
, isec
),
445 (unsigned long) sec_start
,
446 (unsigned long) sec_end
);
448 if (data
->load_offset
!= 0 || data
->load_start
!= 0 || data
->load_end
!= 0)
449 printf_filtered (" into memory (%s to %s)\n",
450 paddress (target_gdbarch (),
451 (unsigned long) sec_start
452 + sec_offset
+ data
->load_offset
),
453 paddress (target_gdbarch (),
454 (unsigned long) sec_start
+ sec_offset
455 + data
->load_offset
+ sec_load_count
));
457 puts_filtered ("\n");
459 /* Write the data. */
460 ret
= target_write_memory (sec_start
+ sec_offset
+ data
->load_offset
,
461 &buf
[sec_offset
], sec_load_count
);
463 warning (_("restore: memory write failed (%s)."), safe_strerror (ret
));
467 restore_binary_file (const char *filename
, struct callback_data
*data
)
469 gdb_file_up file
= gdb_fopen_cloexec (filename
, FOPEN_RB
);
473 error (_("Failed to open %s: %s"), filename
, safe_strerror (errno
));
475 /* Get the file size for reading. */
476 if (fseek (file
.get (), 0, SEEK_END
) == 0)
478 len
= ftell (file
.get ());
480 perror_with_name (filename
);
483 perror_with_name (filename
);
485 if (len
<= data
->load_start
)
486 error (_("Start address is greater than length of binary file %s."),
489 /* Chop off "len" if it exceeds the requested load_end addr. */
490 if (data
->load_end
!= 0 && data
->load_end
< len
)
491 len
= data
->load_end
;
492 /* Chop off "len" if the requested load_start addr skips some bytes. */
493 if (data
->load_start
> 0)
494 len
-= data
->load_start
;
497 ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
499 (unsigned long) (data
->load_start
+ data
->load_offset
),
500 (unsigned long) (data
->load_start
+ data
->load_offset
+ len
));
502 /* Now set the file pos to the requested load start pos. */
503 if (fseek (file
.get (), data
->load_start
, SEEK_SET
) != 0)
504 perror_with_name (filename
);
506 /* Now allocate a buffer and read the file contents. */
507 gdb::byte_vector
buf (len
);
508 if (fread (buf
.data (), 1, len
, file
.get ()) != len
)
509 perror_with_name (filename
);
511 /* Now write the buffer into target memory. */
512 len
= target_write_memory (data
->load_start
+ data
->load_offset
,
515 warning (_("restore: memory write failed (%s)."), safe_strerror (len
));
519 restore_command (const char *args
, int from_tty
)
521 struct callback_data data
;
524 if (!target_has_execution
)
527 data
.load_offset
= 0;
531 /* Parse the input arguments. First is filename (required). */
532 gdb::unique_xmalloc_ptr
<char> filename
= scan_filename (&args
, NULL
);
533 if (args
!= NULL
&& *args
!= '\0')
535 static const char binary_string
[] = "binary";
537 /* Look for optional "binary" flag. */
538 if (startswith (args
, binary_string
))
541 args
+= strlen (binary_string
);
542 args
= skip_spaces (args
);
544 /* Parse offset (optional). */
545 if (args
!= NULL
&& *args
!= '\0')
546 data
.load_offset
= binary_flag
?
547 parse_and_eval_address (scan_expression (&args
, NULL
).get ()) :
548 parse_and_eval_long (scan_expression (&args
, NULL
).get ());
549 if (args
!= NULL
&& *args
!= '\0')
551 /* Parse start address (optional). */
553 parse_and_eval_long (scan_expression (&args
, NULL
).get ());
554 if (args
!= NULL
&& *args
!= '\0')
556 /* Parse end address (optional). */
557 data
.load_end
= parse_and_eval_long (args
);
558 if (data
.load_end
<= data
.load_start
)
559 error (_("Start must be less than end."));
565 printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
566 filename
.get (), (unsigned long) data
.load_offset
,
567 (unsigned long) data
.load_start
,
568 (unsigned long) data
.load_end
);
572 restore_binary_file (filename
.get (), &data
);
576 /* Open the file for loading. */
577 gdb_bfd_ref_ptr
ibfd (bfd_openr_or_error (filename
.get (), NULL
));
579 /* Process the sections. */
580 bfd_map_over_sections (ibfd
.get (), restore_section_callback
, &data
);
585 srec_dump_command (const char *cmd
, int from_tty
)
587 printf_unfiltered (_("\"dump srec\" must be followed by a subcommand.\n"));
588 help_list (srec_cmdlist
, "dump srec ", all_commands
, gdb_stdout
);
592 ihex_dump_command (const char *cmd
, int from_tty
)
594 printf_unfiltered (_("\"dump ihex\" must be followed by a subcommand.\n"));
595 help_list (ihex_cmdlist
, "dump ihex ", all_commands
, gdb_stdout
);
599 verilog_dump_command (const char *cmd
, int from_tty
)
601 printf_unfiltered (_("\"dump verilog\" must be followed by a subcommand.\n"));
602 help_list (verilog_cmdlist
, "dump verilog ", all_commands
, gdb_stdout
);
606 tekhex_dump_command (const char *cmd
, int from_tty
)
608 printf_unfiltered (_("\"dump tekhex\" must be followed by a subcommand.\n"));
609 help_list (tekhex_cmdlist
, "dump tekhex ", all_commands
, gdb_stdout
);
613 binary_dump_command (const char *cmd
, int from_tty
)
615 printf_unfiltered (_("\"dump binary\" must be followed by a subcommand.\n"));
616 help_list (binary_dump_cmdlist
, "dump binary ", all_commands
, gdb_stdout
);
620 binary_append_command (const char *cmd
, int from_tty
)
622 printf_unfiltered (_("\"append binary\" must be followed by a subcommand.\n"));
623 help_list (binary_append_cmdlist
, "append binary ", all_commands
,
628 _initialize_cli_dump (void)
630 struct cmd_list_element
*c
;
632 add_prefix_cmd ("dump", class_vars
, dump_command
,
633 _("Dump target code/data to a local file."),
634 &dump_cmdlist
, "dump ",
637 add_prefix_cmd ("append", class_vars
, append_command
,
638 _("Append target code/data to a local file."),
639 &append_cmdlist
, "append ",
643 add_dump_command ("memory", dump_memory_command
, "\
644 Write contents of memory to a raw binary file.\n\
645 Arguments are FILE START STOP. Writes the contents of memory within the\n\
646 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
648 add_dump_command ("value", dump_value_command
, "\
649 Write the value of an expression to a raw binary file.\n\
650 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
651 the specified FILE in raw target ordered bytes.");
653 add_prefix_cmd ("srec", all_commands
, srec_dump_command
,
654 _("Write target code/data to an srec file."),
655 &srec_cmdlist
, "dump srec ",
659 add_prefix_cmd ("ihex", all_commands
, ihex_dump_command
,
660 _("Write target code/data to an intel hex file."),
661 &ihex_cmdlist
, "dump ihex ",
665 add_prefix_cmd ("verilog", all_commands
, verilog_dump_command
,
666 _("Write target code/data to a verilog hex file."),
667 &verilog_cmdlist
, "dump verilog ",
671 add_prefix_cmd ("tekhex", all_commands
, tekhex_dump_command
,
672 _("Write target code/data to a tekhex file."),
673 &tekhex_cmdlist
, "dump tekhex ",
677 add_prefix_cmd ("binary", all_commands
, binary_dump_command
,
678 _("Write target code/data to a raw binary file."),
679 &binary_dump_cmdlist
, "dump binary ",
683 add_prefix_cmd ("binary", all_commands
, binary_append_command
,
684 _("Append target code/data to a raw binary file."),
685 &binary_append_cmdlist
, "append binary ",
689 add_cmd ("memory", all_commands
, dump_srec_memory
, _("\
690 Write contents of memory to an srec file.\n\
691 Arguments are FILE START STOP. Writes the contents of memory\n\
692 within the range [START .. STOP) to the specified FILE in srec format."),
695 add_cmd ("value", all_commands
, dump_srec_value
, _("\
696 Write the value of an expression to an srec file.\n\
697 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
698 to the specified FILE in srec format."),
701 add_cmd ("memory", all_commands
, dump_ihex_memory
, _("\
702 Write contents of memory to an ihex file.\n\
703 Arguments are FILE START STOP. Writes the contents of memory within\n\
704 the range [START .. STOP) to the specified FILE in intel hex format."),
707 add_cmd ("value", all_commands
, dump_ihex_value
, _("\
708 Write the value of an expression to an ihex file.\n\
709 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
710 to the specified FILE in intel hex format."),
713 add_cmd ("memory", all_commands
, dump_verilog_memory
, _("\
714 Write contents of memory to a verilog hex file.\n\
715 Arguments are FILE START STOP. Writes the contents of memory within\n\
716 the range [START .. STOP) to the specified FILE in verilog hex format."),
719 add_cmd ("value", all_commands
, dump_verilog_value
, _("\
720 Write the value of an expression to a verilog hex file.\n\
721 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
722 to the specified FILE in verilog hex format."),
725 add_cmd ("memory", all_commands
, dump_tekhex_memory
, _("\
726 Write contents of memory to a tekhex file.\n\
727 Arguments are FILE START STOP. Writes the contents of memory\n\
728 within the range [START .. STOP) to the specified FILE in tekhex format."),
731 add_cmd ("value", all_commands
, dump_tekhex_value
, _("\
732 Write the value of an expression to a tekhex file.\n\
733 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
734 to the specified FILE in tekhex format."),
737 add_cmd ("memory", all_commands
, dump_binary_memory
, _("\
738 Write contents of memory to a raw binary file.\n\
739 Arguments are FILE START STOP. Writes the contents of memory\n\
740 within the range [START .. STOP) to the specified FILE in binary format."),
741 &binary_dump_cmdlist
);
743 add_cmd ("value", all_commands
, dump_binary_value
, _("\
744 Write the value of an expression to a raw binary file.\n\
745 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
746 to the specified FILE in raw target ordered bytes."),
747 &binary_dump_cmdlist
);
749 add_cmd ("memory", all_commands
, append_binary_memory
, _("\
750 Append contents of memory to a raw binary file.\n\
751 Arguments are FILE START STOP. Writes the contents of memory within the\n\
752 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
753 &binary_append_cmdlist
);
755 add_cmd ("value", all_commands
, append_binary_value
, _("\
756 Append the value of an expression to a raw binary file.\n\
757 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
758 to the specified FILE in raw target ordered bytes."),
759 &binary_append_cmdlist
);
761 c
= add_com ("restore", class_vars
, restore_command
, _("\
762 Restore the contents of FILE to target memory.\n\
763 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
764 OFFSET will be added to the base address of the file (default zero).\n\
765 If START and END are given, only the file contents within that range\n\
766 (file relative) will be restored to target memory."));
767 c
->completer
= filename_completer
;
768 /* FIXME: completers for other commands. */