gdb/cli/cli-dump.c

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