GDB (xrefs)
cli-dump.c
Go to the documentation of this file.
1 /* Dump-to-file commands, for GDB, the GNU debugger.
2 
3  Copyright (C) 2002-2015 Free Software Foundation, Inc.
4 
5  Contributed by Red Hat.
6 
7  This file is part of GDB.
8 
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.
13 
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.
18 
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/>. */
21 
22 #include "defs.h"
23 #include "cli/cli-decode.h"
24 #include "cli/cli-cmds.h"
25 #include "value.h"
26 #include "completer.h"
27 #include <ctype.h>
28 #include "target.h"
29 #include "readline/readline.h"
30 #include "gdbcore.h"
31 #include "cli/cli-utils.h"
32 #include "gdb_bfd.h"
33 #include "filestuff.h"
34 
35 
36 static const char *
37 scan_expression_with_cleanup (const char **cmd, const char *def)
38 {
39  if ((*cmd) == NULL || (**cmd) == '\0')
40  {
41  char *exp = xstrdup (def);
42 
43  make_cleanup (xfree, exp);
44  return exp;
45  }
46  else
47  {
48  char *exp;
49  const char *end;
50 
51  end = (*cmd) + strcspn (*cmd, " \t");
52  exp = savestring ((*cmd), end - (*cmd));
53  make_cleanup (xfree, exp);
54  (*cmd) = skip_spaces_const (end);
55  return exp;
56  }
57 }
58 
59 
60 static char *
61 scan_filename_with_cleanup (const char **cmd, const char *defname)
62 {
63  char *filename;
64  char *fullname;
65 
66  /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere. */
67 
68  /* File. */
69  if ((*cmd) == NULL)
70  {
71  if (defname == NULL)
72  error (_("Missing filename."));
73  filename = xstrdup (defname);
74  make_cleanup (xfree, filename);
75  }
76  else
77  {
78  /* FIXME: should parse a possibly quoted string. */
79  const char *end;
80 
81  (*cmd) = skip_spaces_const (*cmd);
82  end = *cmd + strcspn (*cmd, " \t");
83  filename = savestring ((*cmd), end - (*cmd));
84  make_cleanup (xfree, filename);
85  (*cmd) = skip_spaces_const (end);
86  }
87  gdb_assert (filename != NULL);
88 
89  fullname = tilde_expand (filename);
90  make_cleanup (xfree, fullname);
91 
92  return fullname;
93 }
94 
95 static FILE *
96 fopen_with_cleanup (const char *filename, const char *mode)
97 {
98  FILE *file = gdb_fopen_cloexec (filename, mode);
99 
100  if (file == NULL)
101  perror_with_name (filename);
102  make_cleanup_fclose (file);
103  return file;
104 }
105 
106 static bfd *
107 bfd_openr_with_cleanup (const char *filename, const char *target)
108 {
109  bfd *ibfd;
110 
111  ibfd = gdb_bfd_openr (filename, target);
112  if (ibfd == NULL)
113  error (_("Failed to open %s: %s."), filename,
114  bfd_errmsg (bfd_get_error ()));
115 
116  make_cleanup_bfd_unref (ibfd);
117  if (!bfd_check_format (ibfd, bfd_object))
118  error (_("'%s' is not a recognized file format."), filename);
119 
120  return ibfd;
121 }
122 
123 static bfd *
124 bfd_openw_with_cleanup (const char *filename, const char *target,
125  const char *mode)
126 {
127  bfd *obfd;
128 
129  if (*mode == 'w') /* Write: create new file */
130  {
131  obfd = gdb_bfd_openw (filename, target);
132  if (obfd == NULL)
133  error (_("Failed to open %s: %s."), filename,
134  bfd_errmsg (bfd_get_error ()));
135  make_cleanup_bfd_unref (obfd);
136  if (!bfd_set_format (obfd, bfd_object))
137  error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
138  }
139  else if (*mode == 'a') /* Append to existing file. */
140  { /* FIXME -- doesn't work... */
141  error (_("bfd_openw does not work with append."));
142  }
143  else
144  error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
145 
146  return obfd;
147 }
148 
157 
158 static void
159 dump_command (char *cmd, int from_tty)
160 {
161  printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
162  help_list (dump_cmdlist, "dump ", all_commands, gdb_stdout);
163 }
164 
165 static void
166 append_command (char *cmd, int from_tty)
167 {
168  printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
169  help_list (dump_cmdlist, "append ", all_commands, gdb_stdout);
170 }
171 
172 static void
173 dump_binary_file (const char *filename, const char *mode,
174  const bfd_byte *buf, ULONGEST len)
175 {
176  FILE *file;
177  int status;
178 
179  file = fopen_with_cleanup (filename, mode);
180  status = fwrite (buf, len, 1, file);
181  if (status != 1)
182  perror_with_name (filename);
183 }
184 
185 static void
186 dump_bfd_file (const char *filename, const char *mode,
187  const char *target, CORE_ADDR vaddr,
188  const bfd_byte *buf, ULONGEST len)
189 {
190  bfd *obfd;
191  asection *osection;
192 
193  obfd = bfd_openw_with_cleanup (filename, target, mode);
194  osection = bfd_make_section_anyway (obfd, ".newsec");
195  bfd_set_section_size (obfd, osection, len);
196  bfd_set_section_vma (obfd, osection, vaddr);
197  bfd_set_section_alignment (obfd, osection, 0);
198  bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
199  | SEC_ALLOC
200  | SEC_LOAD));
201  osection->entsize = 0;
202  if (!bfd_set_section_contents (obfd, osection, buf, 0, len))
203  warning (_("writing dump file '%s' (%s)"), filename,
204  bfd_errmsg (bfd_get_error ()));
205 }
206 
207 static void
208 dump_memory_to_file (const char *cmd, const char *mode, const char *file_format)
209 {
210  struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
211  CORE_ADDR lo;
212  CORE_ADDR hi;
213  ULONGEST count;
214  const char *filename;
215  void *buf;
216  const char *lo_exp;
217  const char *hi_exp;
218 
219  /* Open the file. */
220  filename = scan_filename_with_cleanup (&cmd, NULL);
221 
222  /* Find the low address. */
223  if (cmd == NULL || *cmd == '\0')
224  error (_("Missing start address."));
225  lo_exp = scan_expression_with_cleanup (&cmd, NULL);
226 
227  /* Find the second address - rest of line. */
228  if (cmd == NULL || *cmd == '\0')
229  error (_("Missing stop address."));
230  hi_exp = cmd;
231 
232  lo = parse_and_eval_address (lo_exp);
233  hi = parse_and_eval_address (hi_exp);
234  if (hi <= lo)
235  error (_("Invalid memory address range (start >= end)."));
236  count = hi - lo;
237 
238  /* FIXME: Should use read_memory_partial() and a magic blocking
239  value. */
240  buf = xmalloc (count);
241  make_cleanup (xfree, buf);
242  read_memory (lo, buf, count);
243 
244  /* Have everything. Open/write the data. */
245  if (file_format == NULL || strcmp (file_format, "binary") == 0)
246  {
247  dump_binary_file (filename, mode, buf, count);
248  }
249  else
250  {
251  dump_bfd_file (filename, mode, file_format, lo, buf, count);
252  }
253 
254  do_cleanups (old_cleanups);
255 }
256 
257 static void
258 dump_memory_command (char *cmd, char *mode)
259 {
260  dump_memory_to_file (cmd, mode, "binary");
261 }
262 
263 static void
264 dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
265 {
266  struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
267  struct value *val;
268  const char *filename;
269 
270  /* Open the file. */
271  filename = scan_filename_with_cleanup (&cmd, NULL);
272 
273  /* Find the value. */
274  if (cmd == NULL || *cmd == '\0')
275  error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
276  val = parse_and_eval (cmd);
277  if (val == NULL)
278  error (_("Invalid expression."));
279 
280  /* Have everything. Open/write the data. */
281  if (file_format == NULL || strcmp (file_format, "binary") == 0)
282  {
283  dump_binary_file (filename, mode, value_contents (val),
284  TYPE_LENGTH (value_type (val)));
285  }
286  else
287  {
288  CORE_ADDR vaddr;
289 
290  if (VALUE_LVAL (val))
291  {
292  vaddr = value_address (val);
293  }
294  else
295  {
296  vaddr = 0;
297  warning (_("value is not an lval: address assumed to be zero"));
298  }
299 
300  dump_bfd_file (filename, mode, file_format, vaddr,
301  value_contents (val),
302  TYPE_LENGTH (value_type (val)));
303  }
304 
305  do_cleanups (old_cleanups);
306 }
307 
308 static void
309 dump_value_command (char *cmd, char *mode)
310 {
311  dump_value_to_file (cmd, mode, "binary");
312 }
313 
314 static void
315 dump_srec_memory (char *args, int from_tty)
316 {
317  dump_memory_to_file (args, FOPEN_WB, "srec");
318 }
319 
320 static void
321 dump_srec_value (char *args, int from_tty)
322 {
323  dump_value_to_file (args, FOPEN_WB, "srec");
324 }
325 
326 static void
327 dump_ihex_memory (char *args, int from_tty)
328 {
329  dump_memory_to_file (args, FOPEN_WB, "ihex");
330 }
331 
332 static void
333 dump_ihex_value (char *args, int from_tty)
334 {
335  dump_value_to_file (args, FOPEN_WB, "ihex");
336 }
337 
338 static void
339 dump_verilog_memory (char *args, int from_tty)
340 {
341  dump_memory_to_file (args, FOPEN_WB, "verilog");
342 }
343 
344 static void
345 dump_verilog_value (char *args, int from_tty)
346 {
347  dump_value_to_file (args, FOPEN_WB, "verilog");
348 }
349 
350 static void
351 dump_tekhex_memory (char *args, int from_tty)
352 {
353  dump_memory_to_file (args, FOPEN_WB, "tekhex");
354 }
355 
356 static void
357 dump_tekhex_value (char *args, int from_tty)
358 {
359  dump_value_to_file (args, FOPEN_WB, "tekhex");
360 }
361 
362 static void
363 dump_binary_memory (char *args, int from_tty)
364 {
365  dump_memory_to_file (args, FOPEN_WB, "binary");
366 }
367 
368 static void
369 dump_binary_value (char *args, int from_tty)
370 {
371  dump_value_to_file (args, FOPEN_WB, "binary");
372 }
373 
374 static void
375 append_binary_memory (char *args, int from_tty)
376 {
377  dump_memory_to_file (args, FOPEN_AB, "binary");
378 }
379 
380 static void
381 append_binary_value (char *args, int from_tty)
382 {
383  dump_value_to_file (args, FOPEN_AB, "binary");
384 }
385 
387 {
388  void (*func) (char *cmd, char *mode);
389  char *mode;
390 };
391 
392 static void
393 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
394 {
395  struct dump_context *d = get_cmd_context (c);
396 
397  d->func (args, d->mode);
398 }
399 
400 static void
401 add_dump_command (char *name, void (*func) (char *args, char *mode),
402  char *descr)
403 
404 {
405  struct cmd_list_element *c;
406  struct dump_context *d;
407 
408  c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
409  c->completer = filename_completer;
410  d = XNEW (struct dump_context);
411  d->func = func;
412  d->mode = FOPEN_WB;
413  set_cmd_context (c, d);
414  c->func = call_dump_func;
415 
416  c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
417  c->completer = filename_completer;
418  d = XNEW (struct dump_context);
419  d->func = func;
420  d->mode = FOPEN_AB;
421  set_cmd_context (c, d);
422  c->func = call_dump_func;
423 
424  /* Replace "Dump " at start of docstring with "Append " (borrowed
425  from [deleted] deprecated_add_show_from_set). */
426  if ( c->doc[0] == 'W'
427  && c->doc[1] == 'r'
428  && c->doc[2] == 'i'
429  && c->doc[3] == 't'
430  && c->doc[4] == 'e'
431  && c->doc[5] == ' ')
432  c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
433 }
434 
435 /* Opaque data for restore_section_callback. */
440 };
441 
442 /* Function: restore_section_callback.
443 
444  Callback function for bfd_map_over_sections.
445  Selectively loads the sections into memory. */
446 
447 static void
448 restore_section_callback (bfd *ibfd, asection *isec, void *args)
449 {
450  struct callback_data *data = args;
451  bfd_vma sec_start = bfd_section_vma (ibfd, isec);
452  bfd_size_type size = bfd_section_size (ibfd, isec);
453  bfd_vma sec_end = sec_start + size;
454  bfd_size_type sec_offset = 0;
455  bfd_size_type sec_load_count = size;
456  struct cleanup *old_chain;
457  gdb_byte *buf;
458  int ret;
459 
460  /* Ignore non-loadable sections, eg. from elf files. */
461  if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
462  return;
463 
464  /* Does the section overlap with the desired restore range? */
465  if (sec_end <= data->load_start
466  || (data->load_end > 0 && sec_start >= data->load_end))
467  {
468  /* No, no useable data in this section. */
469  printf_filtered (_("skipping section %s...\n"),
470  bfd_section_name (ibfd, isec));
471  return;
472  }
473 
474  /* Compare section address range with user-requested
475  address range (if any). Compute where the actual
476  transfer should start and end. */
477  if (sec_start < data->load_start)
478  sec_offset = data->load_start - sec_start;
479  /* Size of a partial transfer. */
480  sec_load_count -= sec_offset;
481  if (data->load_end > 0 && sec_end > data->load_end)
482  sec_load_count -= sec_end - data->load_end;
483 
484  /* Get the data. */
485  buf = xmalloc (size);
486  old_chain = make_cleanup (xfree, buf);
487  if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
488  error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
489  bfd_errmsg (bfd_get_error ()));
490 
491  printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
492  bfd_section_name (ibfd, isec),
493  (unsigned long) sec_start,
494  (unsigned long) sec_end);
495 
496  if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
497  printf_filtered (" into memory (%s to %s)\n",
499  (unsigned long) sec_start
500  + sec_offset + data->load_offset),
502  (unsigned long) sec_start + sec_offset
503  + data->load_offset + sec_load_count));
504  else
505  puts_filtered ("\n");
506 
507  /* Write the data. */
508  ret = target_write_memory (sec_start + sec_offset + data->load_offset,
509  buf + sec_offset, sec_load_count);
510  if (ret != 0)
511  warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
512  do_cleanups (old_chain);
513  return;
514 }
515 
516 static void
517 restore_binary_file (const char *filename, struct callback_data *data)
518 {
519  struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
520  FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
521  gdb_byte *buf;
522  long len;
523 
524  /* Get the file size for reading. */
525  if (fseek (file, 0, SEEK_END) == 0)
526  {
527  len = ftell (file);
528  if (len < 0)
529  perror_with_name (filename);
530  }
531  else
532  perror_with_name (filename);
533 
534  if (len <= data->load_start)
535  error (_("Start address is greater than length of binary file %s."),
536  filename);
537 
538  /* Chop off "len" if it exceeds the requested load_end addr. */
539  if (data->load_end != 0 && data->load_end < len)
540  len = data->load_end;
541  /* Chop off "len" if the requested load_start addr skips some bytes. */
542  if (data->load_start > 0)
543  len -= data->load_start;
544 
546  ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
547  filename,
548  (unsigned long) (data->load_start + data->load_offset),
549  (unsigned long) (data->load_start + data->load_offset + len));
550 
551  /* Now set the file pos to the requested load start pos. */
552  if (fseek (file, data->load_start, SEEK_SET) != 0)
553  perror_with_name (filename);
554 
555  /* Now allocate a buffer and read the file contents. */
556  buf = xmalloc (len);
557  make_cleanup (xfree, buf);
558  if (fread (buf, 1, len, file) != len)
559  perror_with_name (filename);
560 
561  /* Now write the buffer into target memory. */
562  len = target_write_memory (data->load_start + data->load_offset, buf, len);
563  if (len != 0)
564  warning (_("restore: memory write failed (%s)."), safe_strerror (len));
565  do_cleanups (cleanup);
566 }
567 
568 static void
569 restore_command (char *args_in, int from_tty)
570 {
571  char *filename;
572  struct callback_data data;
573  bfd *ibfd;
574  int binary_flag = 0;
575  const char *args = args_in;
576 
578  noprocess ();
579 
580  data.load_offset = 0;
581  data.load_start = 0;
582  data.load_end = 0;
583 
584  /* Parse the input arguments. First is filename (required). */
585  filename = scan_filename_with_cleanup (&args, NULL);
586  if (args != NULL && *args != '\0')
587  {
588  char *binary_string = "binary";
589 
590  /* Look for optional "binary" flag. */
591  if (startswith (args, binary_string))
592  {
593  binary_flag = 1;
594  args += strlen (binary_string);
595  args = skip_spaces_const (args);
596  }
597  /* Parse offset (optional). */
598  if (args != NULL && *args != '\0')
599  data.load_offset =
601  if (args != NULL && *args != '\0')
602  {
603  /* Parse start address (optional). */
604  data.load_start =
606  if (args != NULL && *args != '\0')
607  {
608  /* Parse end address (optional). */
609  data.load_end = parse_and_eval_long (args);
610  if (data.load_end <= data.load_start)
611  error (_("Start must be less than end."));
612  }
613  }
614  }
615 
616  if (info_verbose)
617  printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
618  filename, (unsigned long) data.load_offset,
619  (unsigned long) data.load_start,
620  (unsigned long) data.load_end);
621 
622  if (binary_flag)
623  {
624  restore_binary_file (filename, &data);
625  }
626  else
627  {
628  /* Open the file for loading. */
629  ibfd = bfd_openr_with_cleanup (filename, NULL);
630 
631  /* Process the sections. */
632  bfd_map_over_sections (ibfd, restore_section_callback, &data);
633  }
634  return;
635 }
636 
637 static void
638 srec_dump_command (char *cmd, int from_tty)
639 {
640  printf_unfiltered (_("\"dump srec\" must be followed by a subcommand.\n"));
641  help_list (srec_cmdlist, "dump srec ", all_commands, gdb_stdout);
642 }
643 
644 static void
645 ihex_dump_command (char *cmd, int from_tty)
646 {
647  printf_unfiltered (_("\"dump ihex\" must be followed by a subcommand.\n"));
648  help_list (ihex_cmdlist, "dump ihex ", all_commands, gdb_stdout);
649 }
650 
651 static void
652 verilog_dump_command (char *cmd, int from_tty)
653 {
654  printf_unfiltered (_("\"dump verilog\" must be followed by a subcommand.\n"));
655  help_list (verilog_cmdlist, "dump verilog ", all_commands, gdb_stdout);
656 }
657 
658 static void
659 tekhex_dump_command (char *cmd, int from_tty)
660 {
661  printf_unfiltered (_("\"dump tekhex\" must be followed by a subcommand.\n"));
662  help_list (tekhex_cmdlist, "dump tekhex ", all_commands, gdb_stdout);
663 }
664 
665 static void
666 binary_dump_command (char *cmd, int from_tty)
667 {
668  printf_unfiltered (_("\"dump binary\" must be followed by a subcommand.\n"));
669  help_list (binary_dump_cmdlist, "dump binary ", all_commands, gdb_stdout);
670 }
671 
672 static void
673 binary_append_command (char *cmd, int from_tty)
674 {
675  printf_unfiltered (_("\"append binary\" must be followed by a subcommand.\n"));
676  help_list (binary_append_cmdlist, "append binary ", all_commands,
677  gdb_stdout);
678 }
679 
680 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
681 
682 void
684 {
685  struct cmd_list_element *c;
686 
688  _("Dump target code/data to a local file."),
689  &dump_cmdlist, "dump ",
690  0/*allow-unknown*/,
691  &cmdlist);
693  _("Append target code/data to a local file."),
694  &append_cmdlist, "append ",
695  0/*allow-unknown*/,
696  &cmdlist);
697 
699 Write contents of memory to a raw binary file.\n\
700 Arguments are FILE START STOP. Writes the contents of memory within the\n\
701 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
702 
704 Write the value of an expression to a raw binary file.\n\
705 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION to\n\
706 the specified FILE in raw target ordered bytes.");
707 
709  _("Write target code/data to an srec file."),
710  &srec_cmdlist, "dump srec ",
711  0 /*allow-unknown*/,
712  &dump_cmdlist);
713 
715  _("Write target code/data to an intel hex file."),
716  &ihex_cmdlist, "dump ihex ",
717  0 /*allow-unknown*/,
718  &dump_cmdlist);
719 
721  _("Write target code/data to a verilog hex file."),
722  &verilog_cmdlist, "dump verilog ",
723  0 /*allow-unknown*/,
724  &dump_cmdlist);
725 
727  _("Write target code/data to a tekhex file."),
728  &tekhex_cmdlist, "dump tekhex ",
729  0 /*allow-unknown*/,
730  &dump_cmdlist);
731 
733  _("Write target code/data to a raw binary file."),
734  &binary_dump_cmdlist, "dump binary ",
735  0 /*allow-unknown*/,
736  &dump_cmdlist);
737 
739  _("Append target code/data to a raw binary file."),
740  &binary_append_cmdlist, "append binary ",
741  0 /*allow-unknown*/,
742  &append_cmdlist);
743 
744  add_cmd ("memory", all_commands, dump_srec_memory, _("\
745 Write contents of memory to an srec 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 srec format."),
748  &srec_cmdlist);
749 
750  add_cmd ("value", all_commands, dump_srec_value, _("\
751 Write the value of an expression to an srec file.\n\
752 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
753 to the specified FILE in srec format."),
754  &srec_cmdlist);
755 
756  add_cmd ("memory", all_commands, dump_ihex_memory, _("\
757 Write contents of memory to an ihex file.\n\
758 Arguments are FILE START STOP. Writes the contents of memory within\n\
759 the range [START .. STOP) to the specified FILE in intel hex format."),
760  &ihex_cmdlist);
761 
762  add_cmd ("value", all_commands, dump_ihex_value, _("\
763 Write the value of an expression to an ihex file.\n\
764 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
765 to the specified FILE in intel hex format."),
766  &ihex_cmdlist);
767 
768  add_cmd ("memory", all_commands, dump_verilog_memory, _("\
769 Write contents of memory to a verilog hex file.\n\
770 Arguments are FILE START STOP. Writes the contents of memory within\n\
771 the range [START .. STOP) to the specified FILE in verilog hex format."),
772  &verilog_cmdlist);
773 
775 Write the value of an expression to a verilog hex file.\n\
776 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
777 to the specified FILE in verilog hex format."),
778  &verilog_cmdlist);
779 
780  add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
781 Write contents of memory to a tekhex file.\n\
782 Arguments are FILE START STOP. Writes the contents of memory\n\
783 within the range [START .. STOP) to the specified FILE in tekhex format."),
784  &tekhex_cmdlist);
785 
786  add_cmd ("value", all_commands, dump_tekhex_value, _("\
787 Write the value of an expression to a tekhex file.\n\
788 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
789 to the specified FILE in tekhex format."),
790  &tekhex_cmdlist);
791 
792  add_cmd ("memory", all_commands, dump_binary_memory, _("\
793 Write contents of memory to a raw binary file.\n\
794 Arguments are FILE START STOP. Writes the contents of memory\n\
795 within the range [START .. STOP) to the specified FILE in binary format."),
796  &binary_dump_cmdlist);
797 
798  add_cmd ("value", all_commands, dump_binary_value, _("\
799 Write the value of an expression to a raw binary file.\n\
800 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
801 to the specified FILE in raw target ordered bytes."),
802  &binary_dump_cmdlist);
803 
805 Append contents of memory to a raw binary file.\n\
806 Arguments are FILE START STOP. Writes the contents of memory within the\n\
807 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
808  &binary_append_cmdlist);
809 
811 Append the value of an expression to a raw binary file.\n\
812 Arguments are FILE EXPRESSION. Writes the value of EXPRESSION\n\
813 to the specified FILE in raw target ordered bytes."),
814  &binary_append_cmdlist);
815 
816  c = add_com ("restore", class_vars, restore_command, _("\
817 Restore the contents of FILE to target memory.\n\
818 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
819 OFFSET will be added to the base address of the file (default zero).\n\
820 If START and END are given, only the file contents within that range\n\
821 (file relative) will be restored to target memory."));
822  c->completer = filename_completer;
823  /* FIXME: completers for other commands. */
824 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
void set_cmd_context(struct cmd_list_element *cmd, void *context)
Definition: cli-decode.c:141
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
void(* func)(char *cmd, char *mode)
Definition: cli-dump.c:388
static struct cmd_list_element * binary_append_cmdlist
Definition: cli-dump.c:156
static void restore_binary_file(const char *filename, struct callback_data *data)
Definition: cli-dump.c:517
void * get_cmd_context(struct cmd_list_element *cmd)
Definition: cli-decode.c:147
bfd_vma CORE_ADDR
Definition: common-types.h:41
static struct cmd_list_element * srec_cmdlist
Definition: cli-dump.c:151
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1474
void xfree(void *)
Definition: common-utils.c:97
void(* func)(char *)
static void dump_command(char *cmd, int from_tty)
Definition: cli-dump.c:159
void warning(const char *fmt,...)
Definition: errors.c:26
static void restore_section_callback(bfd *ibfd, asection *isec, void *args)
Definition: cli-dump.c:448
struct ui_file * gdb_stdout
Definition: main.c:71
static FILE * fopen_with_cleanup(const char *filename, const char *mode)
Definition: cli-dump.c:96
CORE_ADDR load_offset
Definition: cli-dump.c:437
static void dump_verilog_value(char *args, int from_tty)
Definition: cli-dump.c:345
int info_verbose
Definition: top.c:1699
static void dump_bfd_file(const char *filename, const char *mode, const char *target, CORE_ADDR vaddr, const bfd_byte *buf, ULONGEST len)
Definition: cli-dump.c:186
static void ihex_dump_command(char *cmd, int from_tty)
Definition: cli-dump.c:645
static void dump_tekhex_memory(char *args, int from_tty)
Definition: cli-dump.c:351
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
FILE * gdb_fopen_cloexec(const char *filename, const char *opentype)
Definition: filestuff.c:304
static void append_binary_memory(char *args, int from_tty)
Definition: cli-dump.c:375
#define _(String)
Definition: gdb_locale.h:40
static void dump_tekhex_value(char *args, int from_tty)
Definition: cli-dump.c:357
static void dump_value_to_file(const char *cmd, const char *mode, const char *file_format)
Definition: cli-dump.c:264
static bfd * bfd_openr_with_cleanup(const char *filename, const char *target)
Definition: cli-dump.c:107
static void restore_command(char *args_in, int from_tty)
Definition: cli-dump.c:569
#define VALUE_LVAL(val)
Definition: value.h:411
static struct cmd_list_element * verilog_cmdlist
Definition: cli-dump.c:153
static void binary_dump_command(char *cmd, int from_tty)
Definition: cli-dump.c:666
CORE_ADDR load_start
Definition: cli-dump.c:438
void printf_filtered(const char *format,...)
Definition: utils.c:2388
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
void null_cleanup(void *arg)
Definition: cleanups.c:295
initialize_file_ftype _initialize_cli_dump
static void dump_srec_memory(char *args, int from_tty)
Definition: cli-dump.c:315
static void tekhex_dump_command(char *cmd, int from_tty)
Definition: cli-dump.c:659
static void binary_append_command(char *cmd, int from_tty)
Definition: cli-dump.c:673
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
static struct cmd_list_element * tekhex_cmdlist
Definition: cli-dump.c:154
static char * scan_filename_with_cleanup(const char **cmd, const char *defname)
Definition: cli-dump.c:61
static void append_binary_value(char *args, int from_tty)
Definition: cli-dump.c:381
void initialize_file_ftype(void)
Definition: defs.h:281
static void append_command(char *cmd, int from_tty)
Definition: cli-dump.c:166
static void dump_value_command(char *cmd, char *mode)
Definition: cli-dump.c:309
const char * skip_spaces_const(const char *chp)
Definition: common-utils.c:271
static void verilog_dump_command(char *cmd, int from_tty)
Definition: cli-dump.c:652
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
void puts_filtered(const char *string)
Definition: utils.c:2428
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
static bfd * bfd_openw_with_cleanup(const char *filename, const char *target, const char *mode)
Definition: cli-dump.c:124
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
static void dump_ihex_value(char *args, int from_tty)
Definition: cli-dump.c:333
char * mode
Definition: cli-dump.c:389
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
#define target_has_execution
Definition: target.h:1726
static void dump_memory_to_file(const char *cmd, const char *mode, const char *file_format)
Definition: cli-dump.c:208
static void dump_verilog_memory(char *args, int from_tty)
Definition: cli-dump.c:339
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
static void dump_binary_value(char *args, int from_tty)
Definition: cli-dump.c:369
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
void * xmalloc(YYSIZE_T)
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
static struct cmd_list_element * dump_cmdlist
Definition: cli-dump.c:149
static void add_dump_command(char *name, void(*func)(char *args, char *mode), char *descr)
Definition: cli-dump.c:401
Definition: value.c:172
static struct cmd_list_element * binary_dump_cmdlist
Definition: cli-dump.c:155
bfd * gdb_bfd_openw(const char *filename, const char *target)
Definition: gdb_bfd.c:702
struct cleanup * make_cleanup_fclose(FILE *file)
Definition: utils.c:207
bfd_byte gdb_byte
Definition: common-types.h:38
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
static void srec_dump_command(char *cmd, int from_tty)
Definition: cli-dump.c:638
static void dump_ihex_memory(char *args, int from_tty)
Definition: cli-dump.c:327
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
#define SEEK_SET
Definition: defs.h:87
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:96
char * safe_strerror(int)
void(* func)(struct cmd_list_element *c, char *args, int from_tty)
Definition: cli-decode.h:111
CORE_ADDR load_end
Definition: cli-dump.c:439
struct value * parse_and_eval(const char *exp)
Definition: eval.c:124
unsigned long long ULONGEST
Definition: common-types.h:53
char * savestring(const char *ptr, size_t len)
Definition: common-utils.c:148
bfd * gdb_bfd_openr(const char *filename, const char *target)
Definition: gdb_bfd.c:689
static void call_dump_func(struct cmd_list_element *c, char *args, int from_tty)
Definition: cli-dump.c:393
struct type * value_type(const struct value *value)
Definition: value.c:1021
const char * doc
Definition: cli-decode.h:131
static void dump_memory_command(char *cmd, char *mode)
Definition: cli-dump.c:258
static struct cmd_list_element * ihex_cmdlist
Definition: cli-dump.c:152
static void dump_binary_file(const char *filename, const char *mode, const bfd_byte *buf, ULONGEST len)
Definition: cli-dump.c:173
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
static void dump_srec_value(char *args, int from_tty)
Definition: cli-dump.c:321
static struct cmd_list_element * append_cmdlist
Definition: cli-dump.c:150
static void dump_binary_memory(char *args, int from_tty)
Definition: cli-dump.c:363
completer_ftype * completer
Definition: cli-decode.h:177
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
static const char * scan_expression_with_cleanup(const char **cmd, const char *def)
Definition: cli-dump.c:37
void noprocess(void)
Definition: target.c:570
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
const ULONGEST const LONGEST len
Definition: target.h:309
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111