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