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     len = ftell (file);
 515   else
 516     perror_with_name (filename);
 517
 518   if (len <= data->load_start)
 519     error (_("Start address is greater than length of binary file %s."),
 520            filename);
 521
 522   /* Chop off "len" if it exceeds the requested load_end addr.  */
 523   if (data->load_end != 0 && data->load_end < len)
 524     len = data->load_end;
 525   /* Chop off "len" if the requested load_start addr skips some bytes.  */
 526   if (data->load_start > 0)
 527     len -= data->load_start;
 528
 529   printf_filtered
 530     ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
 531      filename,
 532      (unsigned long) (data->load_start + data->load_offset),
 533      (unsigned long) (data->load_start + data->load_offset + len));
 534
 535   /* Now set the file pos to the requested load start pos.  */
 536   if (fseek (file, data->load_start, SEEK_SET) != 0)
 537     perror_with_name (filename);
 538
 539   /* Now allocate a buffer and read the file contents.  */
 540   buf = xmalloc (len);
 541   make_cleanup (xfree, buf);
 542   if (fread (buf, 1, len, file) != len)
 543     perror_with_name (filename);
 544
 545   /* Now write the buffer into target memory.  */
 546   len = target_write_memory (data->load_start + data->load_offset, buf, len);
 547   if (len != 0)
 548     warning (_("restore: memory write failed (%s)."), safe_strerror (len));
 549   return;
 550 }
 551
 552 static void
 553 restore_command (char *args, int from_tty)
 554 {
 555   char *filename;
 556   struct callback_data data;
 557   bfd *ibfd;
 558   int binary_flag = 0;
 559
 560   if (!target_has_execution)
 561     noprocess ();
 562
 563   data.load_offset = 0;
 564   data.load_start  = 0;
 565   data.load_end    = 0;
 566
 567   /* Parse the input arguments.  First is filename (required).  */
 568   filename = scan_filename_with_cleanup (&args, NULL);
 569   if (args != NULL && *args != '\0')
 570     {
 571       char *binary_string = "binary";
 572
 573       /* Look for optional "binary" flag.  */
 574       if (strncmp (args, binary_string, strlen (binary_string)) == 0)
 575         {
 576           binary_flag = 1;
 577           args += strlen (binary_string);
 578           args = skip_spaces (args);
 579         }
 580       /* Parse offset (optional).  */
 581       if (args != NULL && *args != '\0')
 582       data.load_offset =
 583         parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
 584       if (args != NULL && *args != '\0')
 585         {
 586           /* Parse start address (optional).  */
 587           data.load_start =
 588             parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
 589           if (args != NULL && *args != '\0')
 590             {
 591               /* Parse end address (optional).  */
 592               data.load_end = parse_and_eval_long (args);
 593               if (data.load_end <= data.load_start)
 594                 error (_("Start must be less than end."));
 595             }
 596         }
 597     }
 598
 599   if (info_verbose)
 600     printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
 601                      filename, (unsigned long) data.load_offset,
 602                      (unsigned long) data.load_start,
 603                      (unsigned long) data.load_end);
 604
 605   if (binary_flag)
 606     {
 607       restore_binary_file (filename, &data);
 608     }
 609   else
 610     {
 611       /* Open the file for loading.  */
 612       ibfd = bfd_openr_with_cleanup (filename, NULL);
 613
 614       /* Process the sections.  */
 615       bfd_map_over_sections (ibfd, restore_section_callback, &data);
 616     }
 617   return;
 618 }
 619
 620 static void
 621 srec_dump_command (char *cmd, int from_tty)
 622 {
 623   printf_unfiltered ("\"dump srec\" must be followed by a subcommand.\n");
 624   help_list (srec_cmdlist, "dump srec ", -1, gdb_stdout);
 625 }
 626
 627 static void
 628 ihex_dump_command (char *cmd, int from_tty)
 629 {
 630   printf_unfiltered ("\"dump ihex\" must be followed by a subcommand.\n");
 631   help_list (ihex_cmdlist, "dump ihex ", -1, gdb_stdout);
 632 }
 633
 634 static void
 635 tekhex_dump_command (char *cmd, int from_tty)
 636 {
 637   printf_unfiltered ("\"dump tekhex\" must be followed by a subcommand.\n");
 638   help_list (tekhex_cmdlist, "dump tekhex ", -1, gdb_stdout);
 639 }
 640
 641 static void
 642 binary_dump_command (char *cmd, int from_tty)
 643 {
 644   printf_unfiltered ("\"dump binary\" must be followed by a subcommand.\n");
 645   help_list (binary_dump_cmdlist, "dump binary ", -1, gdb_stdout);
 646 }
 647
 648 static void
 649 binary_append_command (char *cmd, int from_tty)
 650 {
 651   printf_unfiltered ("\"append binary\" must be followed by a subcommand.\n");
 652   help_list (binary_append_cmdlist, "append binary ", -1, gdb_stdout);
 653 }
 654
 655 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
 656
 657 void
 658 _initialize_cli_dump (void)
 659 {
 660   struct cmd_list_element *c;
 661
 662   add_prefix_cmd ("dump", class_vars, dump_command,
 663                   _("Dump target code/data to a local file."),
 664                   &dump_cmdlist, "dump ",
 665                   0/*allow-unknown*/,
 666                   &cmdlist);
 667   add_prefix_cmd ("append", class_vars, append_command,
 668                   _("Append target code/data to a local file."),
 669                   &append_cmdlist, "append ",
 670                   0/*allow-unknown*/,
 671                   &cmdlist);
 672
 673   add_dump_command ("memory", dump_memory_command, "\
 674 Write contents of memory to a raw binary file.\n\
 675 Arguments are FILE START STOP.  Writes the contents of memory within the\n\
 676 range [START .. STOP) to the specifed FILE in raw target ordered bytes.");
 677
 678   add_dump_command ("value", dump_value_command, "\
 679 Write the value of an expression to a raw binary file.\n\
 680 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION to\n\
 681 the specified FILE in raw target ordered bytes.");
 682
 683   add_prefix_cmd ("srec", all_commands, srec_dump_command,
 684                   _("Write target code/data to an srec file."),
 685                   &srec_cmdlist, "dump srec ",
 686                   0 /*allow-unknown*/,
 687                   &dump_cmdlist);
 688
 689   add_prefix_cmd ("ihex", all_commands, ihex_dump_command,
 690                   _("Write target code/data to an intel hex file."),
 691                   &ihex_cmdlist, "dump ihex ",
 692                   0 /*allow-unknown*/,
 693                   &dump_cmdlist);
 694
 695   add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command,
 696                   _("Write target code/data to a tekhex file."),
 697                   &tekhex_cmdlist, "dump tekhex ",
 698                   0 /*allow-unknown*/,
 699                   &dump_cmdlist);
 700
 701   add_prefix_cmd ("binary", all_commands, binary_dump_command,
 702                   _("Write target code/data to a raw binary file."),
 703                   &binary_dump_cmdlist, "dump binary ",
 704                   0 /*allow-unknown*/,
 705                   &dump_cmdlist);
 706
 707   add_prefix_cmd ("binary", all_commands, binary_append_command,
 708                   _("Append target code/data to a raw binary file."),
 709                   &binary_append_cmdlist, "append binary ",
 710                   0 /*allow-unknown*/,
 711                   &append_cmdlist);
 712
 713   add_cmd ("memory", all_commands, dump_srec_memory, _("\
 714 Write contents of memory to an srec file.\n\
 715 Arguments are FILE START STOP.  Writes the contents of memory\n\
 716 within the range [START .. STOP) to the specifed FILE in srec format."),
 717            &srec_cmdlist);
 718
 719   add_cmd ("value", all_commands, dump_srec_value, _("\
 720 Write the value of an expression to an srec file.\n\
 721 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 722 to the specified FILE in srec format."),
 723            &srec_cmdlist);
 724
 725   add_cmd ("memory", all_commands, dump_ihex_memory, _("\
 726 Write contents of memory to an ihex file.\n\
 727 Arguments are FILE START STOP.  Writes the contents of memory within\n\
 728 the range [START .. STOP) to the specifed FILE in intel hex format."),
 729            &ihex_cmdlist);
 730
 731   add_cmd ("value", all_commands, dump_ihex_value, _("\
 732 Write the value of an expression to an ihex file.\n\
 733 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 734 to the specified FILE in intel hex format."),
 735            &ihex_cmdlist);
 736
 737   add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
 738 Write contents of memory to a tekhex file.\n\
 739 Arguments are FILE START STOP.  Writes the contents of memory\n\
 740 within the range [START .. STOP) to the specifed FILE in tekhex format."),
 741            &tekhex_cmdlist);
 742
 743   add_cmd ("value", all_commands, dump_tekhex_value, _("\
 744 Write the value of an expression to a tekhex file.\n\
 745 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 746 to the specified FILE in tekhex format."),
 747            &tekhex_cmdlist);
 748
 749   add_cmd ("memory", all_commands, dump_binary_memory, _("\
 750 Write contents of memory to a raw binary file.\n\
 751 Arguments are FILE START STOP.  Writes the contents of memory\n\
 752 within the range [START .. STOP) to the specifed FILE in binary format."),
 753            &binary_dump_cmdlist);
 754
 755   add_cmd ("value", all_commands, dump_binary_value, _("\
 756 Write the value of an expression to a raw binary file.\n\
 757 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 758 to the specified FILE in raw target ordered bytes."),
 759            &binary_dump_cmdlist);
 760
 761   add_cmd ("memory", all_commands, append_binary_memory, _("\
 762 Append contents of memory to a raw binary file.\n\
 763 Arguments are FILE START STOP.  Writes the contents of memory within the\n\
 764 range [START .. STOP) to the specifed FILE in raw target ordered bytes."),
 765            &binary_append_cmdlist);
 766
 767   add_cmd ("value", all_commands, append_binary_value, _("\
 768 Append the value of an expression to a raw binary file.\n\
 769 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 770 to the specified FILE in raw target ordered bytes."),
 771            &binary_append_cmdlist);
 772
 773   c = add_com ("restore", class_vars, restore_command, _("\
 774 Restore the contents of FILE to target memory.\n\
 775 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
 776 OFFSET will be added to the base address of the file (default zero).\n\
 777 If START and END are given, only the file contents within that range\n\
 778 (file relative) will be restored to target memory."));
 779   c->completer = filename_completer;
 780   /* FIXME: completers for other commands.  */
 781 }