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