gdb/cli/cli-dump.c

   1 /* Dump-to-file commands, for GDB, the GNU debugger.
   2
   3    Copyright (c) 2002, 2005, 2007, 2008, 2009 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 "gdb_string.h"
  24 #include "cli/cli-decode.h"
  25 #include "cli/cli-cmds.h"
  26 #include "value.h"
  27 #include "completer.h"
  28 #include "cli/cli-dump.h"
  29 #include "gdb_assert.h"
  30 #include <ctype.h>
  31 #include "target.h"
  32 #include "readline/readline.h"
  33
  34 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
  35
  36
  37 char *
  38 skip_spaces (char *chp)
  39 {
  40   if (chp == NULL)
  41     return NULL;
  42   while (isspace (*chp))
  43     chp++;
  44   return chp;
  45 }
  46
  47 char *
  48 scan_expression_with_cleanup (char **cmd, const char *def)
  49 {
  50   if ((*cmd) == NULL || (**cmd) == '\0')
  51     {
  52       char *exp = xstrdup (def);
  53       make_cleanup (xfree, exp);
  54       return exp;
  55     }
  56   else
  57     {
  58       char *exp;
  59       char *end;
  60
  61       end = (*cmd) + strcspn (*cmd, " \t");
  62       exp = savestring ((*cmd), end - (*cmd));
  63       make_cleanup (xfree, exp);
  64       (*cmd) = skip_spaces (end);
  65       return exp;
  66     }
  67 }
  68
  69
  70 char *
  71 scan_filename_with_cleanup (char **cmd, const char *defname)
  72 {
  73   char *filename;
  74   char *fullname;
  75
  76   /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */
  77
  78   /* File.  */
  79   if ((*cmd) == NULL)
  80     {
  81       if (defname == NULL)
  82         error (_("Missing filename."));
  83       filename = xstrdup (defname);
  84       make_cleanup (xfree, filename);
  85     }
  86   else
  87     {
  88       /* FIXME: should parse a possibly quoted string.  */
  89       char *end;
  90
  91       (*cmd) = skip_spaces (*cmd);
  92       end = *cmd + strcspn (*cmd, " \t");
  93       filename = savestring ((*cmd), end - (*cmd));
  94       make_cleanup (xfree, filename);
  95       (*cmd) = skip_spaces (end);
  96     }
  97   gdb_assert (filename != NULL);
  98
  99   fullname = tilde_expand (filename);
 100   make_cleanup (xfree, fullname);
 101
 102   return fullname;
 103 }
 104
 105 FILE *
 106 fopen_with_cleanup (const char *filename, const char *mode)
 107 {
 108   FILE *file = fopen (filename, mode);
 109   if (file == NULL)
 110     perror_with_name (filename);
 111   make_cleanup_fclose (file);
 112   return file;
 113 }
 114
 115 static bfd *
 116 bfd_openr_with_cleanup (const char *filename, const char *target)
 117 {
 118   bfd *ibfd;
 119
 120   ibfd = bfd_openr (filename, target);
 121   if (ibfd == NULL)
 122     error (_("Failed to open %s: %s."), filename,
 123            bfd_errmsg (bfd_get_error ()));
 124
 125   make_cleanup_bfd_close (ibfd);
 126   if (!bfd_check_format (ibfd, bfd_object))
 127     error (_("'%s' is not a recognized file format."), filename);
 128
 129   return ibfd;
 130 }
 131
 132 static bfd *
 133 bfd_openw_with_cleanup (const char *filename, const char *target,
 134                         const char *mode)
 135 {
 136   bfd *obfd;
 137
 138   if (*mode == 'w')     /* Write: create new file */
 139     {
 140       obfd = bfd_openw (filename, target);
 141       if (obfd == NULL)
 142         error (_("Failed to open %s: %s."), filename,
 143                bfd_errmsg (bfd_get_error ()));
 144       make_cleanup_bfd_close (obfd);
 145       if (!bfd_set_format (obfd, bfd_object))
 146         error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
 147     }
 148   else if (*mode == 'a')        /* Append to existing file */
 149     {   /* FIXME -- doesn't work... */
 150       error (_("bfd_openw does not work with append."));
 151     }
 152   else
 153     error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
 154
 155   return obfd;
 156 }
 157
 158 struct cmd_list_element *dump_cmdlist;
 159 struct cmd_list_element *append_cmdlist;
 160 struct cmd_list_element *srec_cmdlist;
 161 struct cmd_list_element *ihex_cmdlist;
 162 struct cmd_list_element *tekhex_cmdlist;
 163 struct cmd_list_element *binary_dump_cmdlist;
 164 struct cmd_list_element *binary_append_cmdlist;
 165
 166 static void
 167 dump_command (char *cmd, int from_tty)
 168 {
 169   printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
 170   help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
 171 }
 172
 173 static void
 174 append_command (char *cmd, int from_tty)
 175 {
 176   printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
 177   help_list (dump_cmdlist, "append ", -1, gdb_stdout);
 178 }
 179
 180 static void
 181 dump_binary_file (const char *filename, const char *mode,
 182                   const bfd_byte *buf, int len)
 183 {
 184   FILE *file;
 185   int status;
 186
 187   file = fopen_with_cleanup (filename, mode);
 188   status = fwrite (buf, len, 1, file);
 189   if (status != 1)
 190     perror_with_name (filename);
 191 }
 192
 193 static void
 194 dump_bfd_file (const char *filename, const char *mode,
 195                const char *target, CORE_ADDR vaddr,
 196                const bfd_byte *buf, int len)
 197 {
 198   bfd *obfd;
 199   asection *osection;
 200
 201   obfd = bfd_openw_with_cleanup (filename, target, mode);
 202   osection = bfd_make_section_anyway (obfd, ".newsec");
 203   bfd_set_section_size (obfd, osection, len);
 204   bfd_set_section_vma (obfd, osection, vaddr);
 205   bfd_set_section_alignment (obfd, osection, 0);
 206   bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
 207                                           | SEC_ALLOC
 208                                           | SEC_LOAD));
 209   osection->entsize = 0;
 210   bfd_set_section_contents (obfd, osection, buf, 0, len);
 211 }
 212
 213 static void
 214 dump_memory_to_file (char *cmd, char *mode, char *file_format)
 215 {
 216   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
 217   CORE_ADDR lo;
 218   CORE_ADDR hi;
 219   ULONGEST count;
 220   char *filename;
 221   void *buf;
 222   char *lo_exp;
 223   char *hi_exp;
 224   int len;
 225
 226   /* Open the file.  */
 227   filename = scan_filename_with_cleanup (&cmd, NULL);
 228
 229   /* Find the low address.  */
 230   if (cmd == NULL || *cmd == '\0')
 231     error (_("Missing start address."));
 232   lo_exp = scan_expression_with_cleanup (&cmd, NULL);
 233
 234   /* Find the second address - rest of line.  */
 235   if (cmd == NULL || *cmd == '\0')
 236     error (_("Missing stop address."));
 237   hi_exp = cmd;
 238
 239   lo = parse_and_eval_address (lo_exp);
 240   hi = parse_and_eval_address (hi_exp);
 241   if (hi <= lo)
 242     error (_("Invalid memory address range (start >= end)."));
 243   count = hi - lo;
 244
 245   /* FIXME: Should use read_memory_partial() and a magic blocking
 246      value.  */
 247   buf = xmalloc (count);
 248   make_cleanup (xfree, buf);
 249   target_read_memory (lo, buf, count);
 250
 251   /* Have everything.  Open/write the data.  */
 252   if (file_format == NULL || strcmp (file_format, "binary") == 0)
 253     {
 254       dump_binary_file (filename, mode, buf, count);
 255     }
 256   else
 257     {
 258       dump_bfd_file (filename, mode, file_format, lo, buf, count);
 259     }
 260
 261   do_cleanups (old_cleanups);
 262 }
 263
 264 static void
 265 dump_memory_command (char *cmd, char *mode)
 266 {
 267   dump_memory_to_file (cmd, mode, "binary");
 268 }
 269
 270 static void
 271 dump_value_to_file (char *cmd, char *mode, char *file_format)
 272 {
 273   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
 274   struct value *val;
 275   char *filename;
 276
 277   /* Open the file.  */
 278   filename = scan_filename_with_cleanup (&cmd, NULL);
 279
 280   /* Find the value.  */
 281   if (cmd == NULL || *cmd == '\0')
 282     error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
 283   val = parse_and_eval (cmd);
 284   if (val == NULL)
 285     error (_("Invalid expression."));
 286
 287   /* Have everything.  Open/write the data.  */
 288   if (file_format == NULL || strcmp (file_format, "binary") == 0)
 289     {
 290       dump_binary_file (filename, mode, value_contents (val),
 291                         TYPE_LENGTH (value_type (val)));
 292     }
 293   else
 294     {
 295       CORE_ADDR vaddr;
 296
 297       if (VALUE_LVAL (val))
 298         {
 299           vaddr = value_address (val);
 300         }
 301       else
 302         {
 303           vaddr = 0;
 304           warning (_("value is not an lval: address assumed to be zero"));
 305         }
 306
 307       dump_bfd_file (filename, mode, file_format, vaddr,
 308                      value_contents (val),
 309                      TYPE_LENGTH (value_type (val)));
 310     }
 311
 312   do_cleanups (old_cleanups);
 313 }
 314
 315 static void
 316 dump_value_command (char *cmd, char *mode)
 317 {
 318   dump_value_to_file (cmd, mode, "binary");
 319 }
 320
 321 static void
 322 dump_srec_memory (char *args, int from_tty)
 323 {
 324   dump_memory_to_file (args, FOPEN_WB, "srec");
 325 }
 326
 327 static void
 328 dump_srec_value (char *args, int from_tty)
 329 {
 330   dump_value_to_file (args, FOPEN_WB, "srec");
 331 }
 332
 333 static void
 334 dump_ihex_memory (char *args, int from_tty)
 335 {
 336   dump_memory_to_file (args, FOPEN_WB, "ihex");
 337 }
 338
 339 static void
 340 dump_ihex_value (char *args, int from_tty)
 341 {
 342   dump_value_to_file (args, FOPEN_WB, "ihex");
 343 }
 344
 345 static void
 346 dump_tekhex_memory (char *args, int from_tty)
 347 {
 348   dump_memory_to_file (args, FOPEN_WB, "tekhex");
 349 }
 350
 351 static void
 352 dump_tekhex_value (char *args, int from_tty)
 353 {
 354   dump_value_to_file (args, FOPEN_WB, "tekhex");
 355 }
 356
 357 static void
 358 dump_binary_memory (char *args, int from_tty)
 359 {
 360   dump_memory_to_file (args, FOPEN_WB, "binary");
 361 }
 362
 363 static void
 364 dump_binary_value (char *args, int from_tty)
 365 {
 366   dump_value_to_file (args, FOPEN_WB, "binary");
 367 }
 368
 369 static void
 370 append_binary_memory (char *args, int from_tty)
 371 {
 372   dump_memory_to_file (args, FOPEN_AB, "binary");
 373 }
 374
 375 static void
 376 append_binary_value (char *args, int from_tty)
 377 {
 378   dump_value_to_file (args, FOPEN_AB, "binary");
 379 }
 380
 381 struct dump_context
 382 {
 383   void (*func) (char *cmd, char *mode);
 384   char *mode;
 385 };
 386
 387 static void
 388 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
 389 {
 390   struct dump_context *d = get_cmd_context (c);
 391   d->func (args, d->mode);
 392 }
 393
 394 void
 395 add_dump_command (char *name, void (*func) (char *args, char *mode),
 396                   char *descr)
 397
 398 {
 399   struct cmd_list_element *c;
 400   struct dump_context *d;
 401
 402   c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
 403   c->completer =  filename_completer;
 404   d = XMALLOC (struct dump_context);
 405   d->func = func;
 406   d->mode = FOPEN_WB;
 407   set_cmd_context (c, d);
 408   c->func = call_dump_func;
 409
 410   c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
 411   c->completer =  filename_completer;
 412   d = XMALLOC (struct dump_context);
 413   d->func = func;
 414   d->mode = FOPEN_AB;
 415   set_cmd_context (c, d);
 416   c->func = call_dump_func;
 417
 418   /* Replace "Dump " at start of docstring with "Append " (borrowed
 419      from [deleted] deprecated_add_show_from_set).  */
 420   if (   c->doc[0] == 'W'
 421       && c->doc[1] == 'r'
 422       && c->doc[2] == 'i'
 423       && c->doc[3] == 't'
 424       && c->doc[4] == 'e'
 425       && c->doc[5] == ' ')
 426     c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
 427 }
 428
 429 /* Opaque data for restore_section_callback. */
 430 struct callback_data {
 431   CORE_ADDR load_offset;
 432   CORE_ADDR load_start;
 433   CORE_ADDR load_end;
 434 };
 435
 436 /* Function: restore_section_callback.
 437
 438    Callback function for bfd_map_over_sections.
 439    Selectively loads the sections into memory.  */
 440
 441 static void
 442 restore_section_callback (bfd *ibfd, asection *isec, void *args)
 443 {
 444   struct callback_data *data = args;
 445   bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
 446   bfd_size_type size = bfd_section_size (ibfd, isec);
 447   bfd_vma sec_end    = sec_start + size;
 448   bfd_size_type sec_offset = 0;
 449   bfd_size_type sec_load_count = size;
 450   struct cleanup *old_chain;
 451   gdb_byte *buf;
 452   int ret;
 453
 454   /* Ignore non-loadable sections, eg. from elf files. */
 455   if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
 456     return;
 457
 458   /* Does the section overlap with the desired restore range? */
 459   if (sec_end <= data->load_start
 460       || (data->load_end > 0 && sec_start >= data->load_end))
 461     {
 462       /* No, no useable data in this section. */
 463       printf_filtered (_("skipping section %s...\n"),
 464                        bfd_section_name (ibfd, isec));
 465       return;
 466     }
 467
 468   /* Compare section address range with user-requested
 469      address range (if any).  Compute where the actual
 470      transfer should start and end.  */
 471   if (sec_start < data->load_start)
 472     sec_offset = data->load_start - sec_start;
 473   /* Size of a partial transfer: */
 474   sec_load_count -= sec_offset;
 475   if (data->load_end > 0 && sec_end > data->load_end)
 476     sec_load_count -= sec_end - data->load_end;
 477
 478   /* Get the data.  */
 479   buf = xmalloc (size);
 480   old_chain = make_cleanup (xfree, buf);
 481   if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
 482     error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
 483            bfd_errmsg (bfd_get_error ()));
 484
 485   printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
 486                    bfd_section_name (ibfd, isec),
 487                    (unsigned long) sec_start,
 488                    (unsigned long) sec_end);
 489
 490   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
 491     printf_filtered (" into memory (%s to %s)\n",
 492                      paddress (target_gdbarch,
 493                                (unsigned long) sec_start
 494                                + sec_offset + data->load_offset),
 495                      paddress (target_gdbarch,
 496                                (unsigned long) sec_start + sec_offset
 497                                 + data->load_offset + sec_load_count));
 498   else
 499     puts_filtered ("\n");
 500
 501   /* Write the data.  */
 502   ret = target_write_memory (sec_start + sec_offset + data->load_offset,
 503                              buf + sec_offset, sec_load_count);
 504   if (ret != 0)
 505     warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
 506   do_cleanups (old_chain);
 507   return;
 508 }
 509
 510 static void
 511 restore_binary_file (char *filename, struct callback_data *data)
 512 {
 513   FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
 514   int status;
 515   gdb_byte *buf;
 516   long len;
 517
 518   /* Get the file size for reading.  */
 519   if (fseek (file, 0, SEEK_END) == 0)
 520     len = ftell (file);
 521   else
 522     perror_with_name (filename);
 523
 524   if (len <= data->load_start)
 525     error (_("Start address is greater than length of binary file %s."),
 526            filename);
 527
 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;
 534
 535   printf_filtered
 536     ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
 537      filename,
 538      (unsigned long) (data->load_start + data->load_offset),
 539      (unsigned long) (data->load_start + data->load_offset + len));
 540
 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);
 544
 545   /* Now allocate a buffer and read the file contents.  */
 546   buf = xmalloc (len);
 547   make_cleanup (xfree, buf);
 548   if (fread (buf, 1, len, file) != len)
 549     perror_with_name (filename);
 550
 551   /* Now write the buffer into target memory. */
 552   len = target_write_memory (data->load_start + data->load_offset, buf, len);
 553   if (len != 0)
 554     warning (_("restore: memory write failed (%s)."), safe_strerror (len));
 555   return;
 556 }
 557
 558 static void
 559 restore_command (char *args, int from_tty)
 560 {
 561   char *filename;
 562   struct callback_data data;
 563   bfd *ibfd;
 564   int binary_flag = 0;
 565
 566   if (!target_has_execution)
 567     noprocess ();
 568
 569   data.load_offset = 0;
 570   data.load_start  = 0;
 571   data.load_end    = 0;
 572
 573   /* Parse the input arguments.  First is filename (required). */
 574   filename = scan_filename_with_cleanup (&args, NULL);
 575   if (args != NULL && *args != '\0')
 576     {
 577       char *binary_string = "binary";
 578
 579       /* Look for optional "binary" flag.  */
 580       if (strncmp (args, binary_string, strlen (binary_string)) == 0)
 581         {
 582           binary_flag = 1;
 583           args += strlen (binary_string);
 584           args = skip_spaces (args);
 585         }
 586       /* Parse offset (optional). */
 587       if (args != NULL && *args != '\0')
 588       data.load_offset =
 589         parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
 590       if (args != NULL && *args != '\0')
 591         {
 592           /* Parse start address (optional). */
 593           data.load_start =
 594             parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
 595           if (args != NULL && *args != '\0')
 596             {
 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."));
 601             }
 602         }
 603     }
 604
 605   if (info_verbose)
 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);
 610
 611   if (binary_flag)
 612     {
 613       restore_binary_file (filename, &data);
 614     }
 615   else
 616     {
 617       /* Open the file for loading. */
 618       ibfd = bfd_openr_with_cleanup (filename, NULL);
 619
 620       /* Process the sections. */
 621       bfd_map_over_sections (ibfd, restore_section_callback, &data);
 622     }
 623   return;
 624 }
 625
 626 static void
 627 srec_dump_command (char *cmd, int from_tty)
 628 {
 629   printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
 630   help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
 631 }
 632
 633 static void
 634 ihex_dump_command (char *cmd, int from_tty)
 635 {
 636   printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
 637   help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
 638 }
 639
 640 static void
 641 tekhex_dump_command (char *cmd, int from_tty)
 642 {
 643   printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
 644   help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
 645 }
 646
 647 static void
 648 binary_dump_command (char *cmd, int from_tty)
 649 {
 650   printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
 651   help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
 652 }
 653
 654 static void
 655 binary_append_command (char *cmd, int from_tty)
 656 {
 657   printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
 658   help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
 659 }
 660
 661 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
 662
 663 void
 664 _initialize_cli_dump (void)
 665 {
 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 ",
 670                   0/*allow-unknown*/,
 671                   &cmdlist);
 672   add_prefix_cmd ("append", class_vars, append_command, _("\
 673 Append target code/data to a local file."),
 674                   &append_cmdlist, "append ",
 675                   0/*allow-unknown*/,
 676                   &cmdlist);
 677
 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.");
 682
 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.");
 687
 688   add_prefix_cmd ("srec", all_commands, srec_dump_command, _("\
 689 Write target code/data to an srec file."),
 690                   &srec_cmdlist, "dump srec ",
 691                   0 /*allow-unknown*/,
 692                   &dump_cmdlist);
 693
 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 ",
 697                   0 /*allow-unknown*/,
 698                   &dump_cmdlist);
 699
 700   add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command, _("\
 701 Write target code/data to a tekhex file."),
 702                   &tekhex_cmdlist, "dump tekhex ",
 703                   0 /*allow-unknown*/,
 704                   &dump_cmdlist);
 705
 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 ",
 709                   0 /*allow-unknown*/,
 710                   &dump_cmdlist);
 711
 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 ",
 715                   0 /*allow-unknown*/,
 716                   &append_cmdlist);
 717
 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."),
 722            &srec_cmdlist);
 723
 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."),
 728            &srec_cmdlist);
 729
 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."),
 734            &ihex_cmdlist);
 735
 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."),
 740            &ihex_cmdlist);
 741
 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."),
 746            &tekhex_cmdlist);
 747
 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."),
 752            &tekhex_cmdlist);
 753
 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);
 759
 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);
 765
 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);
 771
 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);
 777
 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. */
 786 }