gdb/cli/cli-dump.c

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