gdb/cli/cli-dump.c

   1 /* Dump-to-file commands, for GDB, the GNU debugger.
   2
   3    Copyright (c) 2002, 2005, 2007-2012 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 "gdb_string.h"
  24 #include "cli/cli-decode.h"
  25 #include "cli/cli-cmds.h"
  26 #include "value.h"
  27 #include "completer.h"
  28 #include "cli/cli-dump.h"
  29 #include "gdb_assert.h"
  30 #include <ctype.h>
  31 #include "target.h"
  32 #include "readline/readline.h"
  33 #include "gdbcore.h"
  34 #include "cli/cli-utils.h"
  35
  36 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
  37
  38
  39 char *
  40 scan_expression_with_cleanup (char **cmd, const char *def)
  41 {
  42   if ((*cmd) == NULL || (**cmd) == '\0')
  43     {
  44       char *exp = xstrdup (def);
  45
  46       make_cleanup (xfree, exp);
  47       return exp;
  48     }
  49   else
  50     {
  51       char *exp;
  52       char *end;
  53
  54       end = (*cmd) + strcspn (*cmd, " \t");
  55       exp = savestring ((*cmd), end - (*cmd));
  56       make_cleanup (xfree, exp);
  57       (*cmd) = skip_spaces (end);
  58       return exp;
  59     }
  60 }
  61
  62
  63 char *
  64 scan_filename_with_cleanup (char **cmd, const char *defname)
  65 {
  66   char *filename;
  67   char *fullname;
  68
  69   /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */
  70
  71   /* File.  */
  72   if ((*cmd) == NULL)
  73     {
  74       if (defname == NULL)
  75         error (_("Missing filename."));
  76       filename = xstrdup (defname);
  77       make_cleanup (xfree, filename);
  78     }
  79   else
  80     {
  81       /* FIXME: should parse a possibly quoted string.  */
  82       char *end;
  83
  84       (*cmd) = skip_spaces (*cmd);
  85       end = *cmd + strcspn (*cmd, " \t");
  86       filename = savestring ((*cmd), end - (*cmd));
  87       make_cleanup (xfree, filename);
  88       (*cmd) = skip_spaces (end);
  89     }
  90   gdb_assert (filename != NULL);
  91
  92   fullname = tilde_expand (filename);
  93   make_cleanup (xfree, fullname);
  94
  95   return fullname;
  96 }
  97
  98 FILE *
  99 fopen_with_cleanup (const char *filename, const char *mode)
 100 {
 101   FILE *file = fopen (filename, mode);
 102
 103   if (file == NULL)
 104     perror_with_name (filename);
 105   make_cleanup_fclose (file);
 106   return file;
 107 }
 108
 109 static bfd *
 110 bfd_openr_with_cleanup (const char *filename, const char *target)
 111 {
 112   bfd *ibfd;
 113
 114   ibfd = bfd_openr (filename, target);
 115   if (ibfd == NULL)
 116     error (_("Failed to open %s: %s."), filename,
 117            bfd_errmsg (bfd_get_error ()));
 118
 119   make_cleanup_bfd_close (ibfd);
 120   if (!bfd_check_format (ibfd, bfd_object))
 121     error (_("'%s' is not a recognized file format."), filename);
 122
 123   return ibfd;
 124 }
 125
 126 static bfd *
 127 bfd_openw_with_cleanup (const char *filename, const char *target,
 128                         const char *mode)
 129 {
 130   bfd *obfd;
 131
 132   if (*mode == 'w')     /* Write: create new file */
 133     {
 134       obfd = bfd_openw (filename, target);
 135       if (obfd == NULL)
 136         error (_("Failed to open %s: %s."), filename,
 137                bfd_errmsg (bfd_get_error ()));
 138       make_cleanup_bfd_close (obfd);
 139       if (!bfd_set_format (obfd, bfd_object))
 140         error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
 141     }
 142   else if (*mode == 'a')        /* Append to existing file.  */
 143     {   /* FIXME -- doesn't work...  */
 144       error (_("bfd_openw does not work with append."));
 145     }
 146   else
 147     error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
 148
 149   return obfd;
 150 }
 151
 152 struct cmd_list_element *dump_cmdlist;
 153 struct cmd_list_element *append_cmdlist;
 154 struct cmd_list_element *srec_cmdlist;
 155 struct cmd_list_element *ihex_cmdlist;
 156 struct cmd_list_element *tekhex_cmdlist;
 157 struct cmd_list_element *binary_dump_cmdlist;
 158 struct cmd_list_element *binary_append_cmdlist;
 159
 160 static void
 161 dump_command (char *cmd, int from_tty)
 162 {
 163   printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
 164   help_list (dump_cmdlist, "dump ", -1, gdb_stdout);
 165 }
 166
 167 static void
 168 append_command (char *cmd, int from_tty)
 169 {
 170   printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
 171   help_list (dump_cmdlist, "append ", -1, gdb_stdout);
 172 }
 173
 174 static void
 175 dump_binary_file (const char *filename, const char *mode,
 176                   const bfd_byte *buf, ULONGEST len)
 177 {
 178   FILE *file;
 179   int status;
 180
 181   file = fopen_with_cleanup (filename, mode);
 182   status = fwrite (buf, len, 1, file);
 183   if (status != 1)
 184     perror_with_name (filename);
 185 }
 186
 187 static void
 188 dump_bfd_file (const char *filename, const char *mode,
 189                const char *target, CORE_ADDR vaddr,
 190                const bfd_byte *buf, ULONGEST len)
 191 {
 192   bfd *obfd;
 193   asection *osection;
 194
 195   obfd = bfd_openw_with_cleanup (filename, target, mode);
 196   osection = bfd_make_section_anyway (obfd, ".newsec");
 197   bfd_set_section_size (obfd, osection, len);
 198   bfd_set_section_vma (obfd, osection, vaddr);
 199   bfd_set_section_alignment (obfd, osection, 0);
 200   bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
 201                                           | SEC_ALLOC
 202                                           | SEC_LOAD));
 203   osection->entsize = 0;
 204   if (!bfd_set_section_contents (obfd, osection, buf, 0, len))
 205     warning (_("writing dump file '%s' (%s)"), filename,
 206              bfd_errmsg (bfd_get_error ()));
 207 }
 208
 209 static void
 210 dump_memory_to_file (char *cmd, char *mode, char *file_format)
 211 {
 212   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
 213   CORE_ADDR lo;
 214   CORE_ADDR hi;
 215   ULONGEST count;
 216   char *filename;
 217   void *buf;
 218   char *lo_exp;
 219   char *hi_exp;
 220
 221   /* Open the file.  */
 222   filename = scan_filename_with_cleanup (&cmd, NULL);
 223
 224   /* Find the low address.  */
 225   if (cmd == NULL || *cmd == '\0')
 226     error (_("Missing start address."));
 227   lo_exp = scan_expression_with_cleanup (&cmd, NULL);
 228
 229   /* Find the second address - rest of line.  */
 230   if (cmd == NULL || *cmd == '\0')
 231     error (_("Missing stop address."));
 232   hi_exp = cmd;
 233
 234   lo = parse_and_eval_address (lo_exp);
 235   hi = parse_and_eval_address (hi_exp);
 236   if (hi <= lo)
 237     error (_("Invalid memory address range (start >= end)."));
 238   count = hi - lo;
 239
 240   /* FIXME: Should use read_memory_partial() and a magic blocking
 241      value.  */
 242   buf = xmalloc (count);
 243   make_cleanup (xfree, buf);
 244   read_memory (lo, buf, count);
 245
 246   /* Have everything.  Open/write the data.  */
 247   if (file_format == NULL || strcmp (file_format, "binary") == 0)
 248     {
 249       dump_binary_file (filename, mode, buf, count);
 250     }
 251   else
 252     {
 253       dump_bfd_file (filename, mode, file_format, lo, buf, count);
 254     }
 255
 256   do_cleanups (old_cleanups);
 257 }
 258
 259 static void
 260 dump_memory_command (char *cmd, char *mode)
 261 {
 262   dump_memory_to_file (cmd, mode, "binary");
 263 }
 264
 265 static void
 266 dump_value_to_file (char *cmd, char *mode, char *file_format)
 267 {
 268   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
 269   struct value *val;
 270   char *filename;
 271
 272   /* Open the file.  */
 273   filename = scan_filename_with_cleanup (&cmd, NULL);
 274
 275   /* Find the value.  */
 276   if (cmd == NULL || *cmd == '\0')
 277     error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
 278   val = parse_and_eval (cmd);
 279   if (val == NULL)
 280     error (_("Invalid expression."));
 281
 282   /* Have everything.  Open/write the data.  */
 283   if (file_format == NULL || strcmp (file_format, "binary") == 0)
 284     {
 285       dump_binary_file (filename, mode, value_contents (val),
 286                         TYPE_LENGTH (value_type (val)));
 287     }
 288   else
 289     {
 290       CORE_ADDR vaddr;
 291
 292       if (VALUE_LVAL (val))
 293         {
 294           vaddr = value_address (val);
 295         }
 296       else
 297         {
 298           vaddr = 0;
 299           warning (_("value is not an lval: address assumed to be zero"));
 300         }
 301
 302       dump_bfd_file (filename, mode, file_format, vaddr,
 303                      value_contents (val),
 304                      TYPE_LENGTH (value_type (val)));
 305     }
 306
 307   do_cleanups (old_cleanups);
 308 }
 309
 310 static void
 311 dump_value_command (char *cmd, char *mode)
 312 {
 313   dump_value_to_file (cmd, mode, "binary");
 314 }
 315
 316 static void
 317 dump_srec_memory (char *args, int from_tty)
 318 {
 319   dump_memory_to_file (args, FOPEN_WB, "srec");
 320 }
 321
 322 static void
 323 dump_srec_value (char *args, int from_tty)
 324 {
 325   dump_value_to_file (args, FOPEN_WB, "srec");
 326 }
 327
 328 static void
 329 dump_ihex_memory (char *args, int from_tty)
 330 {
 331   dump_memory_to_file (args, FOPEN_WB, "ihex");
 332 }
 333
 334 static void
 335 dump_ihex_value (char *args, int from_tty)
 336 {
 337   dump_value_to_file (args, FOPEN_WB, "ihex");
 338 }
 339
 340 static void
 341 dump_tekhex_memory (char *args, int from_tty)
 342 {
 343   dump_memory_to_file (args, FOPEN_WB, "tekhex");
 344 }
 345
 346 static void
 347 dump_tekhex_value (char *args, int from_tty)
 348 {
 349   dump_value_to_file (args, FOPEN_WB, "tekhex");
 350 }
 351
 352 static void
 353 dump_binary_memory (char *args, int from_tty)
 354 {
 355   dump_memory_to_file (args, FOPEN_WB, "binary");
 356 }
 357
 358 static void
 359 dump_binary_value (char *args, int from_tty)
 360 {
 361   dump_value_to_file (args, FOPEN_WB, "binary");
 362 }
 363
 364 static void
 365 append_binary_memory (char *args, int from_tty)
 366 {
 367   dump_memory_to_file (args, FOPEN_AB, "binary");
 368 }
 369
 370 static void
 371 append_binary_value (char *args, int from_tty)
 372 {
 373   dump_value_to_file (args, FOPEN_AB, "binary");
 374 }
 375
 376 struct dump_context
 377 {
 378   void (*func) (char *cmd, char *mode);
 379   char *mode;
 380 };
 381
 382 static void
 383 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
 384 {
 385   struct dump_context *d = get_cmd_context (c);
 386
 387   d->func (args, d->mode);
 388 }
 389
 390 void
 391 add_dump_command (char *name, void (*func) (char *args, char *mode),
 392                   char *descr)
 393
 394 {
 395   struct cmd_list_element *c;
 396   struct dump_context *d;
 397
 398   c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
 399   c->completer =  filename_completer;
 400   d = XMALLOC (struct dump_context);
 401   d->func = func;
 402   d->mode = FOPEN_WB;
 403   set_cmd_context (c, d);
 404   c->func = call_dump_func;
 405
 406   c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
 407   c->completer =  filename_completer;
 408   d = XMALLOC (struct dump_context);
 409   d->func = func;
 410   d->mode = FOPEN_AB;
 411   set_cmd_context (c, d);
 412   c->func = call_dump_func;
 413
 414   /* Replace "Dump " at start of docstring with "Append " (borrowed
 415      from [deleted] deprecated_add_show_from_set).  */
 416   if (   c->doc[0] == 'W'
 417       && c->doc[1] == 'r'
 418       && c->doc[2] == 'i'
 419       && c->doc[3] == 't'
 420       && c->doc[4] == 'e'
 421       && c->doc[5] == ' ')
 422     c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
 423 }
 424
 425 /* Opaque data for restore_section_callback.  */
 426 struct callback_data {
 427   CORE_ADDR load_offset;
 428   CORE_ADDR load_start;
 429   CORE_ADDR load_end;
 430 };
 431
 432 /* Function: restore_section_callback.
 433
 434    Callback function for bfd_map_over_sections.
 435    Selectively loads the sections into memory.  */
 436
 437 static void
 438 restore_section_callback (bfd *ibfd, asection *isec, void *args)
 439 {
 440   struct callback_data *data = args;
 441   bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
 442   bfd_size_type size = bfd_section_size (ibfd, isec);
 443   bfd_vma sec_end    = sec_start + size;
 444   bfd_size_type sec_offset = 0;
 445   bfd_size_type sec_load_count = size;
 446   struct cleanup *old_chain;
 447   gdb_byte *buf;
 448   int ret;
 449
 450   /* Ignore non-loadable sections, eg. from elf files.  */
 451   if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
 452     return;
 453
 454   /* Does the section overlap with the desired restore range? */
 455   if (sec_end <= data->load_start
 456       || (data->load_end > 0 && sec_start >= data->load_end))
 457     {
 458       /* No, no useable data in this section.  */
 459       printf_filtered (_("skipping section %s...\n"),
 460                        bfd_section_name (ibfd, isec));
 461       return;
 462     }
 463
 464   /* Compare section address range with user-requested
 465      address range (if any).  Compute where the actual
 466      transfer should start and end.  */
 467   if (sec_start < data->load_start)
 468     sec_offset = data->load_start - sec_start;
 469   /* Size of a partial transfer.  */
 470   sec_load_count -= sec_offset;
 471   if (data->load_end > 0 && sec_end > data->load_end)
 472     sec_load_count -= sec_end - data->load_end;
 473
 474   /* Get the data.  */
 475   buf = xmalloc (size);
 476   old_chain = make_cleanup (xfree, buf);
 477   if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
 478     error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
 479            bfd_errmsg (bfd_get_error ()));
 480
 481   printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
 482                    bfd_section_name (ibfd, isec),
 483                    (unsigned long) sec_start,
 484                    (unsigned long) sec_end);
 485
 486   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
 487     printf_filtered (" into memory (%s to %s)\n",
 488                      paddress (target_gdbarch,
 489                                (unsigned long) sec_start
 490                                + sec_offset + data->load_offset),
 491                      paddress (target_gdbarch,
 492                                (unsigned long) sec_start + sec_offset
 493                                 + data->load_offset + sec_load_count));
 494   else
 495     puts_filtered ("\n");
 496
 497   /* Write the data.  */
 498   ret = target_write_memory (sec_start + sec_offset + data->load_offset,
 499                              buf + sec_offset, sec_load_count);
 500   if (ret != 0)
 501     warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
 502   do_cleanups (old_chain);
 503   return;
 504 }
 505
 506 static void
 507 restore_binary_file (char *filename, struct callback_data *data)
 508 {
 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   return;
 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 }