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
 227   /* Open the file.  */
 228   filename = scan_filename_with_cleanup (&cmd, NULL);
 229
 230   /* Find the low address.  */
 231   if (cmd == NULL || *cmd == '\0')
 232     error (_("Missing start address."));
 233   lo_exp = scan_expression_with_cleanup (&cmd, NULL);
 234
 235   /* Find the second address - rest of line.  */
 236   if (cmd == NULL || *cmd == '\0')
 237     error (_("Missing stop address."));
 238   hi_exp = cmd;
 239
 240   lo = parse_and_eval_address (lo_exp);
 241   hi = parse_and_eval_address (hi_exp);
 242   if (hi <= lo)
 243     error (_("Invalid memory address range (start >= end)."));
 244   count = hi - lo;
 245
 246   /* FIXME: Should use read_memory_partial() and a magic blocking
 247      value.  */
 248   buf = xmalloc (count);
 249   make_cleanup (xfree, buf);
 250   read_memory (lo, buf, count);
 251
 252   /* Have everything.  Open/write the data.  */
 253   if (file_format == NULL || strcmp (file_format, "binary") == 0)
 254     {
 255       dump_binary_file (filename, mode, buf, count);
 256     }
 257   else
 258     {
 259       dump_bfd_file (filename, mode, file_format, lo, buf, count);
 260     }
 261
 262   do_cleanups (old_cleanups);
 263 }
 264
 265 static void
 266 dump_memory_command (char *cmd, char *mode)
 267 {
 268   dump_memory_to_file (cmd, mode, "binary");
 269 }
 270
 271 static void
 272 dump_value_to_file (char *cmd, char *mode, char *file_format)
 273 {
 274   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
 275   struct value *val;
 276   char *filename;
 277
 278   /* Open the file.  */
 279   filename = scan_filename_with_cleanup (&cmd, NULL);
 280
 281   /* Find the value.  */
 282   if (cmd == NULL || *cmd == '\0')
 283     error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
 284   val = parse_and_eval (cmd);
 285   if (val == NULL)
 286     error (_("Invalid expression."));
 287
 288   /* Have everything.  Open/write the data.  */
 289   if (file_format == NULL || strcmp (file_format, "binary") == 0)
 290     {
 291       dump_binary_file (filename, mode, value_contents (val),
 292                         TYPE_LENGTH (value_type (val)));
 293     }
 294   else
 295     {
 296       CORE_ADDR vaddr;
 297
 298       if (VALUE_LVAL (val))
 299         {
 300           vaddr = value_address (val);
 301         }
 302       else
 303         {
 304           vaddr = 0;
 305           warning (_("value is not an lval: address assumed to be zero"));
 306         }
 307
 308       dump_bfd_file (filename, mode, file_format, vaddr,
 309                      value_contents (val),
 310                      TYPE_LENGTH (value_type (val)));
 311     }
 312
 313   do_cleanups (old_cleanups);
 314 }
 315
 316 static void
 317 dump_value_command (char *cmd, char *mode)
 318 {
 319   dump_value_to_file (cmd, mode, "binary");
 320 }
 321
 322 static void
 323 dump_srec_memory (char *args, int from_tty)
 324 {
 325   dump_memory_to_file (args, FOPEN_WB, "srec");
 326 }
 327
 328 static void
 329 dump_srec_value (char *args, int from_tty)
 330 {
 331   dump_value_to_file (args, FOPEN_WB, "srec");
 332 }
 333
 334 static void
 335 dump_ihex_memory (char *args, int from_tty)
 336 {
 337   dump_memory_to_file (args, FOPEN_WB, "ihex");
 338 }
 339
 340 static void
 341 dump_ihex_value (char *args, int from_tty)
 342 {
 343   dump_value_to_file (args, FOPEN_WB, "ihex");
 344 }
 345
 346 static void
 347 dump_tekhex_memory (char *args, int from_tty)
 348 {
 349   dump_memory_to_file (args, FOPEN_WB, "tekhex");
 350 }
 351
 352 static void
 353 dump_tekhex_value (char *args, int from_tty)
 354 {
 355   dump_value_to_file (args, FOPEN_WB, "tekhex");
 356 }
 357
 358 static void
 359 dump_binary_memory (char *args, int from_tty)
 360 {
 361   dump_memory_to_file (args, FOPEN_WB, "binary");
 362 }
 363
 364 static void
 365 dump_binary_value (char *args, int from_tty)
 366 {
 367   dump_value_to_file (args, FOPEN_WB, "binary");
 368 }
 369
 370 static void
 371 append_binary_memory (char *args, int from_tty)
 372 {
 373   dump_memory_to_file (args, FOPEN_AB, "binary");
 374 }
 375
 376 static void
 377 append_binary_value (char *args, int from_tty)
 378 {
 379   dump_value_to_file (args, FOPEN_AB, "binary");
 380 }
 381
 382 struct dump_context
 383 {
 384   void (*func) (char *cmd, char *mode);
 385   char *mode;
 386 };
 387
 388 static void
 389 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
 390 {
 391   struct dump_context *d = get_cmd_context (c);
 392   d->func (args, d->mode);
 393 }
 394
 395 void
 396 add_dump_command (char *name, void (*func) (char *args, char *mode),
 397                   char *descr)
 398
 399 {
 400   struct cmd_list_element *c;
 401   struct dump_context *d;
 402
 403   c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
 404   c->completer =  filename_completer;
 405   d = XMALLOC (struct dump_context);
 406   d->func = func;
 407   d->mode = FOPEN_WB;
 408   set_cmd_context (c, d);
 409   c->func = call_dump_func;
 410
 411   c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
 412   c->completer =  filename_completer;
 413   d = XMALLOC (struct dump_context);
 414   d->func = func;
 415   d->mode = FOPEN_AB;
 416   set_cmd_context (c, d);
 417   c->func = call_dump_func;
 418
 419   /* Replace "Dump " at start of docstring with "Append " (borrowed
 420      from [deleted] deprecated_add_show_from_set).  */
 421   if (   c->doc[0] == 'W'
 422       && c->doc[1] == 'r'
 423       && c->doc[2] == 'i'
 424       && c->doc[3] == 't'
 425       && c->doc[4] == 'e'
 426       && c->doc[5] == ' ')
 427     c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
 428 }
 429
 430 /* Opaque data for restore_section_callback. */
 431 struct callback_data {
 432   CORE_ADDR load_offset;
 433   CORE_ADDR load_start;
 434   CORE_ADDR load_end;
 435 };
 436
 437 /* Function: restore_section_callback.
 438
 439    Callback function for bfd_map_over_sections.
 440    Selectively loads the sections into memory.  */
 441
 442 static void
 443 restore_section_callback (bfd *ibfd, asection *isec, void *args)
 444 {
 445   struct callback_data *data = args;
 446   bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
 447   bfd_size_type size = bfd_section_size (ibfd, isec);
 448   bfd_vma sec_end    = sec_start + size;
 449   bfd_size_type sec_offset = 0;
 450   bfd_size_type sec_load_count = size;
 451   struct cleanup *old_chain;
 452   gdb_byte *buf;
 453   int ret;
 454
 455   /* Ignore non-loadable sections, eg. from elf files. */
 456   if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
 457     return;
 458
 459   /* Does the section overlap with the desired restore range? */
 460   if (sec_end <= data->load_start
 461       || (data->load_end > 0 && sec_start >= data->load_end))
 462     {
 463       /* No, no useable data in this section. */
 464       printf_filtered (_("skipping section %s...\n"),
 465                        bfd_section_name (ibfd, isec));
 466       return;
 467     }
 468
 469   /* Compare section address range with user-requested
 470      address range (if any).  Compute where the actual
 471      transfer should start and end.  */
 472   if (sec_start < data->load_start)
 473     sec_offset = data->load_start - sec_start;
 474   /* Size of a partial transfer: */
 475   sec_load_count -= sec_offset;
 476   if (data->load_end > 0 && sec_end > data->load_end)
 477     sec_load_count -= sec_end - data->load_end;
 478
 479   /* Get the data.  */
 480   buf = xmalloc (size);
 481   old_chain = make_cleanup (xfree, buf);
 482   if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
 483     error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
 484            bfd_errmsg (bfd_get_error ()));
 485
 486   printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
 487                    bfd_section_name (ibfd, isec),
 488                    (unsigned long) sec_start,
 489                    (unsigned long) sec_end);
 490
 491   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
 492     printf_filtered (" into memory (%s to %s)\n",
 493                      paddress (target_gdbarch,
 494                                (unsigned long) sec_start
 495                                + sec_offset + data->load_offset),
 496                      paddress (target_gdbarch,
 497                                (unsigned long) sec_start + sec_offset
 498                                 + data->load_offset + sec_load_count));
 499   else
 500     puts_filtered ("\n");
 501
 502   /* Write the data.  */
 503   ret = target_write_memory (sec_start + sec_offset + data->load_offset,
 504                              buf + sec_offset, sec_load_count);
 505   if (ret != 0)
 506     warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
 507   do_cleanups (old_chain);
 508   return;
 509 }
 510
 511 static void
 512 restore_binary_file (char *filename, struct callback_data *data)
 513 {
 514   FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
 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 }