gdb/cli/cli-dump.c

   1 /* Dump-to-file commands, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2014 Free Software Foundation, Inc.
   4
   5    Contributed by Red Hat.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include <string.h>
  24 #include "cli/cli-decode.h"
  25 #include "cli/cli-cmds.h"
  26 #include "value.h"
  27 #include "completer.h"
  28 #include "gdb_assert.h"
  29 #include <ctype.h>
  30 #include "target.h"
  31 #include "readline/readline.h"
  32 #include "gdbcore.h"
  33 #include "cli/cli-utils.h"
  34 #include "gdb_bfd.h"
  35 #include "filestuff.h"
  36
  37
  38 static char *
  39 scan_expression_with_cleanup (char **cmd, const char *def)
  40 {
  41   if ((*cmd) == NULL || (**cmd) == '\0')
  42     {
  43       char *exp = xstrdup (def);
  44
  45       make_cleanup (xfree, exp);
  46       return exp;
  47     }
  48   else
  49     {
  50       char *exp;
  51       char *end;
  52
  53       end = (*cmd) + strcspn (*cmd, " \t");
  54       exp = savestring ((*cmd), end - (*cmd));
  55       make_cleanup (xfree, exp);
  56       (*cmd) = skip_spaces (end);
  57       return exp;
  58     }
  59 }
  60
  61
  62 static char *
  63 scan_filename_with_cleanup (char **cmd, const char *defname)
  64 {
  65   char *filename;
  66   char *fullname;
  67
  68   /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */
  69
  70   /* File.  */
  71   if ((*cmd) == NULL)
  72     {
  73       if (defname == NULL)
  74         error (_("Missing filename."));
  75       filename = xstrdup (defname);
  76       make_cleanup (xfree, filename);
  77     }
  78   else
  79     {
  80       /* FIXME: should parse a possibly quoted string.  */
  81       char *end;
  82
  83       (*cmd) = skip_spaces (*cmd);
  84       end = *cmd + strcspn (*cmd, " \t");
  85       filename = savestring ((*cmd), end - (*cmd));
  86       make_cleanup (xfree, filename);
  87       (*cmd) = skip_spaces (end);
  88     }
  89   gdb_assert (filename != NULL);
  90
  91   fullname = tilde_expand (filename);
  92   make_cleanup (xfree, fullname);
  93
  94   return fullname;
  95 }
  96
  97 static FILE *
  98 fopen_with_cleanup (const char *filename, const char *mode)
  99 {
 100   FILE *file = gdb_fopen_cloexec (filename, mode);
 101
 102   if (file == NULL)
 103     perror_with_name (filename);
 104   make_cleanup_fclose (file);
 105   return file;
 106 }
 107
 108 static bfd *
 109 bfd_openr_with_cleanup (const char *filename, const char *target)
 110 {
 111   bfd *ibfd;
 112
 113   ibfd = gdb_bfd_openr (filename, target);
 114   if (ibfd == NULL)
 115     error (_("Failed to open %s: %s."), filename,
 116            bfd_errmsg (bfd_get_error ()));
 117
 118   make_cleanup_bfd_unref (ibfd);
 119   if (!bfd_check_format (ibfd, bfd_object))
 120     error (_("'%s' is not a recognized file format."), filename);
 121
 122   return ibfd;
 123 }
 124
 125 static bfd *
 126 bfd_openw_with_cleanup (const char *filename, const char *target,
 127                         const char *mode)
 128 {
 129   bfd *obfd;
 130
 131   if (*mode == 'w')     /* Write: create new file */
 132     {
 133       obfd = gdb_bfd_openw (filename, target);
 134       if (obfd == NULL)
 135         error (_("Failed to open %s: %s."), filename,
 136                bfd_errmsg (bfd_get_error ()));
 137       make_cleanup_bfd_unref (obfd);
 138       if (!bfd_set_format (obfd, bfd_object))
 139         error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
 140     }
 141   else if (*mode == 'a')        /* Append to existing file.  */
 142     {   /* FIXME -- doesn't work...  */
 143       error (_("bfd_openw does not work with append."));
 144     }
 145   else
 146     error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
 147
 148   return obfd;
 149 }
 150
 151 static struct cmd_list_element *dump_cmdlist;
 152 static struct cmd_list_element *append_cmdlist;
 153 static struct cmd_list_element *srec_cmdlist;
 154 static struct cmd_list_element *ihex_cmdlist;
 155 static struct cmd_list_element *tekhex_cmdlist;
 156 static struct cmd_list_element *binary_dump_cmdlist;
 157 static struct cmd_list_element *binary_append_cmdlist;
 158
 159 static void
 160 dump_command (char *cmd, int from_tty)
 161 {
 162   printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
 163   help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
 164 }
 165
 166 static void
 167 append_command (char *cmd, int from_tty)
 168 {
 169   printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
 170   help_list (dump_cmdlist, "append ", -1, gdb_stdout);
 171 }
 172
 173 static void
 174 dump_binary_file (const char *filename, const char *mode,
 175                   const bfd_byte *buf, ULONGEST len)
 176 {
 177   FILE *file;
 178   int status;
 179
 180   file = fopen_with_cleanup (filename, mode);
 181   status = fwrite (buf, len, 1, file);
 182   if (status != 1)
 183     perror_with_name (filename);
 184 }
 185
 186 static void
 187 dump_bfd_file (const char *filename, const char *mode,
 188                const char *target, CORE_ADDR vaddr,
 189                const bfd_byte *buf, ULONGEST len)
 190 {
 191   bfd *obfd;
 192   asection *osection;
 193
 194   obfd = bfd_openw_with_cleanup (filename, target, mode);
 195   osection = bfd_make_section_anyway (obfd, ".newsec");
 196   bfd_set_section_size (obfd, osection, len);
 197   bfd_set_section_vma (obfd, osection, vaddr);
 198   bfd_set_section_alignment (obfd, osection, 0);
 199   bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
 200                                           | SEC_ALLOC
 201                                           | SEC_LOAD));
 202   osection->entsize = 0;
 203   if (!bfd_set_section_contents (obfd, osection, buf, 0, len))
 204     warning (_("writing dump file '%s' (%s)"), filename,
 205              bfd_errmsg (bfd_get_error ()));
 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 static 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 = XNEW (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 = XNEW (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   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 509   FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
 510   gdb_byte *buf;
 511   long len;
 512
 513   /* Get the file size for reading.  */
 514   if (fseek (file, 0, SEEK_END) == 0)
 515     {
 516       len = ftell (file);
 517       if (len < 0)
 518         perror_with_name (filename);
 519     }
 520   else
 521     perror_with_name (filename);
 522
 523   if (len <= data->load_start)
 524     error (_("Start address is greater than length of binary file %s."),
 525            filename);
 526
 527   /* Chop off "len" if it exceeds the requested load_end addr.  */
 528   if (data->load_end != 0 && data->load_end < len)
 529     len = data->load_end;
 530   /* Chop off "len" if the requested load_start addr skips some bytes.  */
 531   if (data->load_start > 0)
 532     len -= data->load_start;
 533
 534   printf_filtered
 535     ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
 536      filename,
 537      (unsigned long) (data->load_start + data->load_offset),
 538      (unsigned long) (data->load_start + data->load_offset + len));
 539
 540   /* Now set the file pos to the requested load start pos.  */
 541   if (fseek (file, data->load_start, SEEK_SET) != 0)
 542     perror_with_name (filename);
 543
 544   /* Now allocate a buffer and read the file contents.  */
 545   buf = xmalloc (len);
 546   make_cleanup (xfree, buf);
 547   if (fread (buf, 1, len, file) != len)
 548     perror_with_name (filename);
 549
 550   /* Now write the buffer into target memory.  */
 551   len = target_write_memory (data->load_start + data->load_offset, buf, len);
 552   if (len != 0)
 553     warning (_("restore: memory write failed (%s)."), safe_strerror (len));
 554   do_cleanups (cleanup);
 555 }
 556
 557 static void
 558 restore_command (char *args, int from_tty)
 559 {
 560   char *filename;
 561   struct callback_data data;
 562   bfd *ibfd;
 563   int binary_flag = 0;
 564
 565   if (!target_has_execution)
 566     noprocess ();
 567
 568   data.load_offset = 0;
 569   data.load_start  = 0;
 570   data.load_end    = 0;
 571
 572   /* Parse the input arguments.  First is filename (required).  */
 573   filename = scan_filename_with_cleanup (&args, NULL);
 574   if (args != NULL && *args != '\0')
 575     {
 576       char *binary_string = "binary";
 577
 578       /* Look for optional "binary" flag.  */
 579       if (strncmp (args, binary_string, strlen (binary_string)) == 0)
 580         {
 581           binary_flag = 1;
 582           args += strlen (binary_string);
 583           args = skip_spaces (args);
 584         }
 585       /* Parse offset (optional).  */
 586       if (args != NULL && *args != '\0')
 587       data.load_offset =
 588         parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
 589       if (args != NULL && *args != '\0')
 590         {
 591           /* Parse start address (optional).  */
 592           data.load_start =
 593             parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
 594           if (args != NULL && *args != '\0')
 595             {
 596               /* Parse end address (optional).  */
 597               data.load_end = parse_and_eval_long (args);
 598               if (data.load_end <= data.load_start)
 599                 error (_("Start must be less than end."));
 600             }
 601         }
 602     }
 603
 604   if (info_verbose)
 605     printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
 606                      filename, (unsigned long) data.load_offset,
 607                      (unsigned long) data.load_start,
 608                      (unsigned long) data.load_end);
 609
 610   if (binary_flag)
 611     {
 612       restore_binary_file (filename, &data);
 613     }
 614   else
 615     {
 616       /* Open the file for loading.  */
 617       ibfd = bfd_openr_with_cleanup (filename, NULL);
 618
 619       /* Process the sections.  */
 620       bfd_map_over_sections (ibfd, restore_section_callback, &data);
 621     }
 622   return;
 623 }
 624
 625 static void
 626 srec_dump_command (char *cmd, int from_tty)
 627 {
 628   printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
 629   help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
 630 }
 631
 632 static void
 633 ihex_dump_command (char *cmd, int from_tty)
 634 {
 635   printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
 636   help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
 637 }
 638
 639 static void
 640 tekhex_dump_command (char *cmd, int from_tty)
 641 {
 642   printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
 643   help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
 644 }
 645
 646 static void
 647 binary_dump_command (char *cmd, int from_tty)
 648 {
 649   printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
 650   help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
 651 }
 652
 653 static void
 654 binary_append_command (char *cmd, int from_tty)
 655 {
 656   printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
 657   help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
 658 }
 659
 660 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
 661
 662 void
 663 _initialize_cli_dump (void)
 664 {
 665   struct cmd_list_element *c;
 666
 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 specified 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 specified 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 specified 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 specified 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 specified 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 specified 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 }