gdb/cli/cli-dump.c

   1 /* Dump-to-file commands, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2016 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 "cli/cli-decode.h"
  24 #include "cli/cli-cmds.h"
  25 #include "value.h"
  26 #include "completer.h"
  27 #include <ctype.h>
  28 #include "target.h"
  29 #include "readline/readline.h"
  30 #include "gdbcore.h"
  31 #include "cli/cli-utils.h"
  32 #include "gdb_bfd.h"
  33 #include "filestuff.h"
  34
  35
  36 static const char *
  37 scan_expression_with_cleanup (const char **cmd, const char *def)
  38 {
  39   if ((*cmd) == NULL || (**cmd) == '\0')
  40     {
  41       char *exp = xstrdup (def);
  42
  43       make_cleanup (xfree, exp);
  44       return exp;
  45     }
  46   else
  47     {
  48       char *exp;
  49       const char *end;
  50
  51       end = (*cmd) + strcspn (*cmd, " \t");
  52       exp = savestring ((*cmd), end - (*cmd));
  53       make_cleanup (xfree, exp);
  54       (*cmd) = skip_spaces_const (end);
  55       return exp;
  56     }
  57 }
  58
  59
  60 static char *
  61 scan_filename_with_cleanup (const char **cmd, const char *defname)
  62 {
  63   char *filename;
  64   char *fullname;
  65
  66   /* FIXME: Need to get the ``/a(ppend)'' flag from somewhere.  */
  67
  68   /* File.  */
  69   if ((*cmd) == NULL)
  70     {
  71       if (defname == NULL)
  72         error (_("Missing filename."));
  73       filename = xstrdup (defname);
  74       make_cleanup (xfree, filename);
  75     }
  76   else
  77     {
  78       /* FIXME: should parse a possibly quoted string.  */
  79       const char *end;
  80
  81       (*cmd) = skip_spaces_const (*cmd);
  82       end = *cmd + strcspn (*cmd, " \t");
  83       filename = savestring ((*cmd), end - (*cmd));
  84       make_cleanup (xfree, filename);
  85       (*cmd) = skip_spaces_const (end);
  86     }
  87   gdb_assert (filename != NULL);
  88
  89   fullname = tilde_expand (filename);
  90   make_cleanup (xfree, fullname);
  91
  92   return fullname;
  93 }
  94
  95 static FILE *
  96 fopen_with_cleanup (const char *filename, const char *mode)
  97 {
  98   FILE *file = gdb_fopen_cloexec (filename, mode);
  99
 100   if (file == NULL)
 101     perror_with_name (filename);
 102   make_cleanup_fclose (file);
 103   return file;
 104 }
 105
 106 static bfd *
 107 bfd_openr_with_cleanup (const char *filename, const char *target)
 108 {
 109   bfd *ibfd;
 110
 111   ibfd = gdb_bfd_openr (filename, target);
 112   if (ibfd == NULL)
 113     error (_("Failed to open %s: %s."), filename,
 114            bfd_errmsg (bfd_get_error ()));
 115
 116   make_cleanup_bfd_unref (ibfd);
 117   if (!bfd_check_format (ibfd, bfd_object))
 118     error (_("'%s' is not a recognized file format."), filename);
 119
 120   return ibfd;
 121 }
 122
 123 static bfd *
 124 bfd_openw_with_cleanup (const char *filename, const char *target,
 125                         const char *mode)
 126 {
 127   bfd *obfd;
 128
 129   if (*mode == 'w')     /* Write: create new file */
 130     {
 131       obfd = gdb_bfd_openw (filename, target);
 132       if (obfd == NULL)
 133         error (_("Failed to open %s: %s."), filename,
 134                bfd_errmsg (bfd_get_error ()));
 135       make_cleanup_bfd_unref (obfd);
 136       if (!bfd_set_format (obfd, bfd_object))
 137         error (_("bfd_openw_with_cleanup: %s."), bfd_errmsg (bfd_get_error ()));
 138     }
 139   else if (*mode == 'a')        /* Append to existing file.  */
 140     {   /* FIXME -- doesn't work...  */
 141       error (_("bfd_openw does not work with append."));
 142     }
 143   else
 144     error (_("bfd_openw_with_cleanup: unknown mode %s."), mode);
 145
 146   return obfd;
 147 }
 148
 149 static struct cmd_list_element *dump_cmdlist;
 150 static struct cmd_list_element *append_cmdlist;
 151 static struct cmd_list_element *srec_cmdlist;
 152 static struct cmd_list_element *ihex_cmdlist;
 153 static struct cmd_list_element *verilog_cmdlist;
 154 static struct cmd_list_element *tekhex_cmdlist;
 155 static struct cmd_list_element *binary_dump_cmdlist;
 156 static struct cmd_list_element *binary_append_cmdlist;
 157
 158 static void
 159 dump_command (char *cmd, int from_tty)
 160 {
 161   printf_unfiltered (_("\"dump\" must be followed by a subcommand.\n\n"));
 162   help_list (dump_cmdlist, "dump ", all_commands, gdb_stdout);
 163 }
 164
 165 static void
 166 append_command (char *cmd, int from_tty)
 167 {
 168   printf_unfiltered (_("\"append\" must be followed by a subcommand.\n\n"));
 169   help_list (dump_cmdlist, "append ", all_commands, gdb_stdout);
 170 }
 171
 172 static void
 173 dump_binary_file (const char *filename, const char *mode,
 174                   const bfd_byte *buf, ULONGEST len)
 175 {
 176   FILE *file;
 177   int status;
 178
 179   file = fopen_with_cleanup (filename, mode);
 180   status = fwrite (buf, len, 1, file);
 181   if (status != 1)
 182     perror_with_name (filename);
 183 }
 184
 185 static void
 186 dump_bfd_file (const char *filename, const char *mode,
 187                const char *target, CORE_ADDR vaddr,
 188                const bfd_byte *buf, ULONGEST len)
 189 {
 190   bfd *obfd;
 191   asection *osection;
 192
 193   obfd = bfd_openw_with_cleanup (filename, target, mode);
 194   osection = bfd_make_section_anyway (obfd, ".newsec");
 195   bfd_set_section_size (obfd, osection, len);
 196   bfd_set_section_vma (obfd, osection, vaddr);
 197   bfd_set_section_alignment (obfd, osection, 0);
 198   bfd_set_section_flags (obfd, osection, (SEC_HAS_CONTENTS
 199                                           | SEC_ALLOC
 200                                           | SEC_LOAD));
 201   osection->entsize = 0;
 202   if (!bfd_set_section_contents (obfd, osection, buf, 0, len))
 203     warning (_("writing dump file '%s' (%s)"), filename,
 204              bfd_errmsg (bfd_get_error ()));
 205 }
 206
 207 static void
 208 dump_memory_to_file (const char *cmd, const char *mode, const char *file_format)
 209 {
 210   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
 211   CORE_ADDR lo;
 212   CORE_ADDR hi;
 213   ULONGEST count;
 214   const char *filename;
 215   gdb_byte *buf;
 216   const char *lo_exp;
 217   const char *hi_exp;
 218
 219   /* Open the file.  */
 220   filename = scan_filename_with_cleanup (&cmd, NULL);
 221
 222   /* Find the low address.  */
 223   if (cmd == NULL || *cmd == '\0')
 224     error (_("Missing start address."));
 225   lo_exp = scan_expression_with_cleanup (&cmd, NULL);
 226
 227   /* Find the second address - rest of line.  */
 228   if (cmd == NULL || *cmd == '\0')
 229     error (_("Missing stop address."));
 230   hi_exp = cmd;
 231
 232   lo = parse_and_eval_address (lo_exp);
 233   hi = parse_and_eval_address (hi_exp);
 234   if (hi <= lo)
 235     error (_("Invalid memory address range (start >= end)."));
 236   count = hi - lo;
 237
 238   /* FIXME: Should use read_memory_partial() and a magic blocking
 239      value.  */
 240   buf = (gdb_byte *) xmalloc (count);
 241   make_cleanup (xfree, buf);
 242   read_memory (lo, buf, count);
 243
 244   /* Have everything.  Open/write the data.  */
 245   if (file_format == NULL || strcmp (file_format, "binary") == 0)
 246     {
 247       dump_binary_file (filename, mode, buf, count);
 248     }
 249   else
 250     {
 251       dump_bfd_file (filename, mode, file_format, lo, buf, count);
 252     }
 253
 254   do_cleanups (old_cleanups);
 255 }
 256
 257 static void
 258 dump_memory_command (char *cmd, char *mode)
 259 {
 260   dump_memory_to_file (cmd, mode, "binary");
 261 }
 262
 263 static void
 264 dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
 265 {
 266   struct cleanup *old_cleanups = make_cleanup (null_cleanup, NULL);
 267   struct value *val;
 268   const char *filename;
 269
 270   /* Open the file.  */
 271   filename = scan_filename_with_cleanup (&cmd, NULL);
 272
 273   /* Find the value.  */
 274   if (cmd == NULL || *cmd == '\0')
 275     error (_("No value to %s."), *mode == 'a' ? "append" : "dump");
 276   val = parse_and_eval (cmd);
 277   if (val == NULL)
 278     error (_("Invalid expression."));
 279
 280   /* Have everything.  Open/write the data.  */
 281   if (file_format == NULL || strcmp (file_format, "binary") == 0)
 282     {
 283       dump_binary_file (filename, mode, value_contents (val),
 284                         TYPE_LENGTH (value_type (val)));
 285     }
 286   else
 287     {
 288       CORE_ADDR vaddr;
 289
 290       if (VALUE_LVAL (val))
 291         {
 292           vaddr = value_address (val);
 293         }
 294       else
 295         {
 296           vaddr = 0;
 297           warning (_("value is not an lval: address assumed to be zero"));
 298         }
 299
 300       dump_bfd_file (filename, mode, file_format, vaddr,
 301                      value_contents (val),
 302                      TYPE_LENGTH (value_type (val)));
 303     }
 304
 305   do_cleanups (old_cleanups);
 306 }
 307
 308 static void
 309 dump_value_command (char *cmd, char *mode)
 310 {
 311   dump_value_to_file (cmd, mode, "binary");
 312 }
 313
 314 static void
 315 dump_srec_memory (char *args, int from_tty)
 316 {
 317   dump_memory_to_file (args, FOPEN_WB, "srec");
 318 }
 319
 320 static void
 321 dump_srec_value (char *args, int from_tty)
 322 {
 323   dump_value_to_file (args, FOPEN_WB, "srec");
 324 }
 325
 326 static void
 327 dump_ihex_memory (char *args, int from_tty)
 328 {
 329   dump_memory_to_file (args, FOPEN_WB, "ihex");
 330 }
 331
 332 static void
 333 dump_ihex_value (char *args, int from_tty)
 334 {
 335   dump_value_to_file (args, FOPEN_WB, "ihex");
 336 }
 337
 338 static void
 339 dump_verilog_memory (char *args, int from_tty)
 340 {
 341   dump_memory_to_file (args, FOPEN_WB, "verilog");
 342 }
 343
 344 static void
 345 dump_verilog_value (char *args, int from_tty)
 346 {
 347   dump_value_to_file (args, FOPEN_WB, "verilog");
 348 }
 349
 350 static void
 351 dump_tekhex_memory (char *args, int from_tty)
 352 {
 353   dump_memory_to_file (args, FOPEN_WB, "tekhex");
 354 }
 355
 356 static void
 357 dump_tekhex_value (char *args, int from_tty)
 358 {
 359   dump_value_to_file (args, FOPEN_WB, "tekhex");
 360 }
 361
 362 static void
 363 dump_binary_memory (char *args, int from_tty)
 364 {
 365   dump_memory_to_file (args, FOPEN_WB, "binary");
 366 }
 367
 368 static void
 369 dump_binary_value (char *args, int from_tty)
 370 {
 371   dump_value_to_file (args, FOPEN_WB, "binary");
 372 }
 373
 374 static void
 375 append_binary_memory (char *args, int from_tty)
 376 {
 377   dump_memory_to_file (args, FOPEN_AB, "binary");
 378 }
 379
 380 static void
 381 append_binary_value (char *args, int from_tty)
 382 {
 383   dump_value_to_file (args, FOPEN_AB, "binary");
 384 }
 385
 386 struct dump_context
 387 {
 388   void (*func) (char *cmd, char *mode);
 389   char *mode;
 390 };
 391
 392 static void
 393 call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
 394 {
 395   struct dump_context *d = (struct dump_context *) get_cmd_context (c);
 396
 397   d->func (args, d->mode);
 398 }
 399
 400 static void
 401 add_dump_command (char *name, void (*func) (char *args, char *mode),
 402                   char *descr)
 403
 404 {
 405   struct cmd_list_element *c;
 406   struct dump_context *d;
 407
 408   c = add_cmd (name, all_commands, NULL, descr, &dump_cmdlist);
 409   c->completer =  filename_completer;
 410   d = XNEW (struct dump_context);
 411   d->func = func;
 412   d->mode = FOPEN_WB;
 413   set_cmd_context (c, d);
 414   c->func = call_dump_func;
 415
 416   c = add_cmd (name, all_commands, NULL, descr, &append_cmdlist);
 417   c->completer =  filename_completer;
 418   d = XNEW (struct dump_context);
 419   d->func = func;
 420   d->mode = FOPEN_AB;
 421   set_cmd_context (c, d);
 422   c->func = call_dump_func;
 423
 424   /* Replace "Dump " at start of docstring with "Append " (borrowed
 425      from [deleted] deprecated_add_show_from_set).  */
 426   if (   c->doc[0] == 'W'
 427       && c->doc[1] == 'r'
 428       && c->doc[2] == 'i'
 429       && c->doc[3] == 't'
 430       && c->doc[4] == 'e'
 431       && c->doc[5] == ' ')
 432     c->doc = concat ("Append ", c->doc + 6, (char *)NULL);
 433 }
 434
 435 /* Opaque data for restore_section_callback.  */
 436 struct callback_data {
 437   CORE_ADDR load_offset;
 438   CORE_ADDR load_start;
 439   CORE_ADDR load_end;
 440 };
 441
 442 /* Function: restore_section_callback.
 443
 444    Callback function for bfd_map_over_sections.
 445    Selectively loads the sections into memory.  */
 446
 447 static void
 448 restore_section_callback (bfd *ibfd, asection *isec, void *args)
 449 {
 450   struct callback_data *data = (struct callback_data *) args;
 451   bfd_vma sec_start  = bfd_section_vma (ibfd, isec);
 452   bfd_size_type size = bfd_section_size (ibfd, isec);
 453   bfd_vma sec_end    = sec_start + size;
 454   bfd_size_type sec_offset = 0;
 455   bfd_size_type sec_load_count = size;
 456   struct cleanup *old_chain;
 457   gdb_byte *buf;
 458   int ret;
 459
 460   /* Ignore non-loadable sections, eg. from elf files.  */
 461   if (!(bfd_get_section_flags (ibfd, isec) & SEC_LOAD))
 462     return;
 463
 464   /* Does the section overlap with the desired restore range? */
 465   if (sec_end <= data->load_start
 466       || (data->load_end > 0 && sec_start >= data->load_end))
 467     {
 468       /* No, no useable data in this section.  */
 469       printf_filtered (_("skipping section %s...\n"),
 470                        bfd_section_name (ibfd, isec));
 471       return;
 472     }
 473
 474   /* Compare section address range with user-requested
 475      address range (if any).  Compute where the actual
 476      transfer should start and end.  */
 477   if (sec_start < data->load_start)
 478     sec_offset = data->load_start - sec_start;
 479   /* Size of a partial transfer.  */
 480   sec_load_count -= sec_offset;
 481   if (data->load_end > 0 && sec_end > data->load_end)
 482     sec_load_count -= sec_end - data->load_end;
 483
 484   /* Get the data.  */
 485   buf = (gdb_byte *) xmalloc (size);
 486   old_chain = make_cleanup (xfree, buf);
 487   if (!bfd_get_section_contents (ibfd, isec, buf, 0, size))
 488     error (_("Failed to read bfd file %s: '%s'."), bfd_get_filename (ibfd),
 489            bfd_errmsg (bfd_get_error ()));
 490
 491   printf_filtered ("Restoring section %s (0x%lx to 0x%lx)",
 492                    bfd_section_name (ibfd, isec),
 493                    (unsigned long) sec_start,
 494                    (unsigned long) sec_end);
 495
 496   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
 497     printf_filtered (" into memory (%s to %s)\n",
 498                      paddress (target_gdbarch (),
 499                                (unsigned long) sec_start
 500                                + sec_offset + data->load_offset),
 501                      paddress (target_gdbarch (),
 502                                (unsigned long) sec_start + sec_offset
 503                                 + data->load_offset + sec_load_count));
 504   else
 505     puts_filtered ("\n");
 506
 507   /* Write the data.  */
 508   ret = target_write_memory (sec_start + sec_offset + data->load_offset,
 509                              buf + sec_offset, sec_load_count);
 510   if (ret != 0)
 511     warning (_("restore: memory write failed (%s)."), safe_strerror (ret));
 512   do_cleanups (old_chain);
 513   return;
 514 }
 515
 516 static void
 517 restore_binary_file (const char *filename, struct callback_data *data)
 518 {
 519   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 520   FILE *file = fopen_with_cleanup (filename, FOPEN_RB);
 521   gdb_byte *buf;
 522   long len;
 523
 524   /* Get the file size for reading.  */
 525   if (fseek (file, 0, SEEK_END) == 0)
 526     {
 527       len = ftell (file);
 528       if (len < 0)
 529         perror_with_name (filename);
 530     }
 531   else
 532     perror_with_name (filename);
 533
 534   if (len <= data->load_start)
 535     error (_("Start address is greater than length of binary file %s."),
 536            filename);
 537
 538   /* Chop off "len" if it exceeds the requested load_end addr.  */
 539   if (data->load_end != 0 && data->load_end < len)
 540     len = data->load_end;
 541   /* Chop off "len" if the requested load_start addr skips some bytes.  */
 542   if (data->load_start > 0)
 543     len -= data->load_start;
 544
 545   printf_filtered
 546     ("Restoring binary file %s into memory (0x%lx to 0x%lx)\n",
 547      filename,
 548      (unsigned long) (data->load_start + data->load_offset),
 549      (unsigned long) (data->load_start + data->load_offset + len));
 550
 551   /* Now set the file pos to the requested load start pos.  */
 552   if (fseek (file, data->load_start, SEEK_SET) != 0)
 553     perror_with_name (filename);
 554
 555   /* Now allocate a buffer and read the file contents.  */
 556   buf = (gdb_byte *) xmalloc (len);
 557   make_cleanup (xfree, buf);
 558   if (fread (buf, 1, len, file) != len)
 559     perror_with_name (filename);
 560
 561   /* Now write the buffer into target memory.  */
 562   len = target_write_memory (data->load_start + data->load_offset, buf, len);
 563   if (len != 0)
 564     warning (_("restore: memory write failed (%s)."), safe_strerror (len));
 565   do_cleanups (cleanup);
 566 }
 567
 568 static void
 569 restore_command (char *args_in, int from_tty)
 570 {
 571   char *filename;
 572   struct callback_data data;
 573   bfd *ibfd;
 574   int binary_flag = 0;
 575   const char *args = args_in;
 576
 577   if (!target_has_execution)
 578     noprocess ();
 579
 580   data.load_offset = 0;
 581   data.load_start  = 0;
 582   data.load_end    = 0;
 583
 584   /* Parse the input arguments.  First is filename (required).  */
 585   filename = scan_filename_with_cleanup (&args, NULL);
 586   if (args != NULL && *args != '\0')
 587     {
 588       char *binary_string = "binary";
 589
 590       /* Look for optional "binary" flag.  */
 591       if (startswith (args, binary_string))
 592         {
 593           binary_flag = 1;
 594           args += strlen (binary_string);
 595           args = skip_spaces_const (args);
 596         }
 597       /* Parse offset (optional).  */
 598       if (args != NULL && *args != '\0')
 599         data.load_offset = binary_flag ?
 600           parse_and_eval_address (scan_expression_with_cleanup (&args, NULL)) :
 601           parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
 602       if (args != NULL && *args != '\0')
 603         {
 604           /* Parse start address (optional).  */
 605           data.load_start =
 606             parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
 607           if (args != NULL && *args != '\0')
 608             {
 609               /* Parse end address (optional).  */
 610               data.load_end = parse_and_eval_long (args);
 611               if (data.load_end <= data.load_start)
 612                 error (_("Start must be less than end."));
 613             }
 614         }
 615     }
 616
 617   if (info_verbose)
 618     printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
 619                      filename, (unsigned long) data.load_offset,
 620                      (unsigned long) data.load_start,
 621                      (unsigned long) data.load_end);
 622
 623   if (binary_flag)
 624     {
 625       restore_binary_file (filename, &data);
 626     }
 627   else
 628     {
 629       /* Open the file for loading.  */
 630       ibfd = bfd_openr_with_cleanup (filename, NULL);
 631
 632       /* Process the sections.  */
 633       bfd_map_over_sections (ibfd, restore_section_callback, &data);
 634     }
 635   return;
 636 }
 637
 638 static void
 639 srec_dump_command (char *cmd, int from_tty)
 640 {
 641   printf_unfiltered (_("\"dump srec\" must be followed by a subcommand.\n"));
 642   help_list (srec_cmdlist, "dump srec ", all_commands, gdb_stdout);
 643 }
 644
 645 static void
 646 ihex_dump_command (char *cmd, int from_tty)
 647 {
 648   printf_unfiltered (_("\"dump ihex\" must be followed by a subcommand.\n"));
 649   help_list (ihex_cmdlist, "dump ihex ", all_commands, gdb_stdout);
 650 }
 651
 652 static void
 653 verilog_dump_command (char *cmd, int from_tty)
 654 {
 655   printf_unfiltered (_("\"dump verilog\" must be followed by a subcommand.\n"));
 656   help_list (verilog_cmdlist, "dump verilog ", all_commands, gdb_stdout);
 657 }
 658
 659 static void
 660 tekhex_dump_command (char *cmd, int from_tty)
 661 {
 662   printf_unfiltered (_("\"dump tekhex\" must be followed by a subcommand.\n"));
 663   help_list (tekhex_cmdlist, "dump tekhex ", all_commands, gdb_stdout);
 664 }
 665
 666 static void
 667 binary_dump_command (char *cmd, int from_tty)
 668 {
 669   printf_unfiltered (_("\"dump binary\" must be followed by a subcommand.\n"));
 670   help_list (binary_dump_cmdlist, "dump binary ", all_commands, gdb_stdout);
 671 }
 672
 673 static void
 674 binary_append_command (char *cmd, int from_tty)
 675 {
 676   printf_unfiltered (_("\"append binary\" must be followed by a subcommand.\n"));
 677   help_list (binary_append_cmdlist, "append binary ", all_commands,
 678              gdb_stdout);
 679 }
 680
 681 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
 682
 683 void
 684 _initialize_cli_dump (void)
 685 {
 686   struct cmd_list_element *c;
 687
 688   add_prefix_cmd ("dump", class_vars, dump_command,
 689                   _("Dump target code/data to a local file."),
 690                   &dump_cmdlist, "dump ",
 691                   0/*allow-unknown*/,
 692                   &cmdlist);
 693   add_prefix_cmd ("append", class_vars, append_command,
 694                   _("Append target code/data to a local file."),
 695                   &append_cmdlist, "append ",
 696                   0/*allow-unknown*/,
 697                   &cmdlist);
 698
 699   add_dump_command ("memory", dump_memory_command, "\
 700 Write contents of memory to a raw binary file.\n\
 701 Arguments are FILE START STOP.  Writes the contents of memory within the\n\
 702 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
 703
 704   add_dump_command ("value", dump_value_command, "\
 705 Write the value of an expression to a raw binary file.\n\
 706 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION to\n\
 707 the specified FILE in raw target ordered bytes.");
 708
 709   add_prefix_cmd ("srec", all_commands, srec_dump_command,
 710                   _("Write target code/data to an srec file."),
 711                   &srec_cmdlist, "dump srec ",
 712                   0 /*allow-unknown*/,
 713                   &dump_cmdlist);
 714
 715   add_prefix_cmd ("ihex", all_commands, ihex_dump_command,
 716                   _("Write target code/data to an intel hex file."),
 717                   &ihex_cmdlist, "dump ihex ",
 718                   0 /*allow-unknown*/,
 719                   &dump_cmdlist);
 720
 721   add_prefix_cmd ("verilog", all_commands, verilog_dump_command,
 722                   _("Write target code/data to a verilog hex file."),
 723                   &verilog_cmdlist, "dump verilog ",
 724                   0 /*allow-unknown*/,
 725                   &dump_cmdlist);
 726
 727   add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command,
 728                   _("Write target code/data to a tekhex file."),
 729                   &tekhex_cmdlist, "dump tekhex ",
 730                   0 /*allow-unknown*/,
 731                   &dump_cmdlist);
 732
 733   add_prefix_cmd ("binary", all_commands, binary_dump_command,
 734                   _("Write target code/data to a raw binary file."),
 735                   &binary_dump_cmdlist, "dump binary ",
 736                   0 /*allow-unknown*/,
 737                   &dump_cmdlist);
 738
 739   add_prefix_cmd ("binary", all_commands, binary_append_command,
 740                   _("Append target code/data to a raw binary file."),
 741                   &binary_append_cmdlist, "append binary ",
 742                   0 /*allow-unknown*/,
 743                   &append_cmdlist);
 744
 745   add_cmd ("memory", all_commands, dump_srec_memory, _("\
 746 Write contents of memory to an srec file.\n\
 747 Arguments are FILE START STOP.  Writes the contents of memory\n\
 748 within the range [START .. STOP) to the specified FILE in srec format."),
 749            &srec_cmdlist);
 750
 751   add_cmd ("value", all_commands, dump_srec_value, _("\
 752 Write the value of an expression to an srec file.\n\
 753 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 754 to the specified FILE in srec format."),
 755            &srec_cmdlist);
 756
 757   add_cmd ("memory", all_commands, dump_ihex_memory, _("\
 758 Write contents of memory to an ihex file.\n\
 759 Arguments are FILE START STOP.  Writes the contents of memory within\n\
 760 the range [START .. STOP) to the specified FILE in intel hex format."),
 761            &ihex_cmdlist);
 762
 763   add_cmd ("value", all_commands, dump_ihex_value, _("\
 764 Write the value of an expression to an ihex file.\n\
 765 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 766 to the specified FILE in intel hex format."),
 767            &ihex_cmdlist);
 768
 769   add_cmd ("memory", all_commands, dump_verilog_memory, _("\
 770 Write contents of memory to a verilog hex file.\n\
 771 Arguments are FILE START STOP.  Writes the contents of memory within\n\
 772 the range [START .. STOP) to the specified FILE in verilog hex format."),
 773            &verilog_cmdlist);
 774
 775   add_cmd ("value", all_commands, dump_verilog_value, _("\
 776 Write the value of an expression to a verilog hex file.\n\
 777 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 778 to the specified FILE in verilog hex format."),
 779            &verilog_cmdlist);
 780
 781   add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
 782 Write contents of memory to a tekhex file.\n\
 783 Arguments are FILE START STOP.  Writes the contents of memory\n\
 784 within the range [START .. STOP) to the specified FILE in tekhex format."),
 785            &tekhex_cmdlist);
 786
 787   add_cmd ("value", all_commands, dump_tekhex_value, _("\
 788 Write the value of an expression to a tekhex file.\n\
 789 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 790 to the specified FILE in tekhex format."),
 791            &tekhex_cmdlist);
 792
 793   add_cmd ("memory", all_commands, dump_binary_memory, _("\
 794 Write contents of memory to a raw binary file.\n\
 795 Arguments are FILE START STOP.  Writes the contents of memory\n\
 796 within the range [START .. STOP) to the specified FILE in binary format."),
 797            &binary_dump_cmdlist);
 798
 799   add_cmd ("value", all_commands, dump_binary_value, _("\
 800 Write the value of an expression to a raw binary file.\n\
 801 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 802 to the specified FILE in raw target ordered bytes."),
 803            &binary_dump_cmdlist);
 804
 805   add_cmd ("memory", all_commands, append_binary_memory, _("\
 806 Append contents of memory to a raw binary file.\n\
 807 Arguments are FILE START STOP.  Writes the contents of memory within the\n\
 808 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
 809            &binary_append_cmdlist);
 810
 811   add_cmd ("value", all_commands, append_binary_value, _("\
 812 Append the value of an expression to a raw binary file.\n\
 813 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 814 to the specified FILE in raw target ordered bytes."),
 815            &binary_append_cmdlist);
 816
 817   c = add_com ("restore", class_vars, restore_command, _("\
 818 Restore the contents of FILE to target memory.\n\
 819 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
 820 OFFSET will be added to the base address of the file (default zero).\n\
 821 If START and END are given, only the file contents within that range\n\
 822 (file relative) will be restored to target memory."));
 823   c->completer = filename_completer;
 824   /* FIXME: completers for other commands.  */
 825 }