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