gdb/cli/cli-dump.c

   1 /* Dump-to-file commands, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2015 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   void *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 = 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 = 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 = 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 = 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 = 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 =
 600         parse_and_eval_address (scan_expression_with_cleanup (&args, NULL));
 601       if (args != NULL && *args != '\0')
 602         {
 603           /* Parse start address (optional).  */
 604           data.load_start =
 605             parse_and_eval_long (scan_expression_with_cleanup (&args, NULL));
 606           if (args != NULL && *args != '\0')
 607             {
 608               /* Parse end address (optional).  */
 609               data.load_end = parse_and_eval_long (args);
 610               if (data.load_end <= data.load_start)
 611                 error (_("Start must be less than end."));
 612             }
 613         }
 614     }
 615
 616   if (info_verbose)
 617     printf_filtered ("Restore file %s offset 0x%lx start 0x%lx end 0x%lx\n",
 618                      filename, (unsigned long) data.load_offset,
 619                      (unsigned long) data.load_start,
 620                      (unsigned long) data.load_end);
 621
 622   if (binary_flag)
 623     {
 624       restore_binary_file (filename, &data);
 625     }
 626   else
 627     {
 628       /* Open the file for loading.  */
 629       ibfd = bfd_openr_with_cleanup (filename, NULL);
 630
 631       /* Process the sections.  */
 632       bfd_map_over_sections (ibfd, restore_section_callback, &data);
 633     }
 634   return;
 635 }
 636
 637 static void
 638 srec_dump_command (char *cmd, int from_tty)
 639 {
 640   printf_unfiltered (_("\"dump srec\" must be followed by a subcommand.\n"));
 641   help_list (srec_cmdlist, "dump srec ", all_commands, gdb_stdout);
 642 }
 643
 644 static void
 645 ihex_dump_command (char *cmd, int from_tty)
 646 {
 647   printf_unfiltered (_("\"dump ihex\" must be followed by a subcommand.\n"));
 648   help_list (ihex_cmdlist, "dump ihex ", all_commands, gdb_stdout);
 649 }
 650
 651 static void
 652 verilog_dump_command (char *cmd, int from_tty)
 653 {
 654   printf_unfiltered (_("\"dump verilog\" must be followed by a subcommand.\n"));
 655   help_list (verilog_cmdlist, "dump verilog ", all_commands, gdb_stdout);
 656 }
 657
 658 static void
 659 tekhex_dump_command (char *cmd, int from_tty)
 660 {
 661   printf_unfiltered (_("\"dump tekhex\" must be followed by a subcommand.\n"));
 662   help_list (tekhex_cmdlist, "dump tekhex ", all_commands, gdb_stdout);
 663 }
 664
 665 static void
 666 binary_dump_command (char *cmd, int from_tty)
 667 {
 668   printf_unfiltered (_("\"dump binary\" must be followed by a subcommand.\n"));
 669   help_list (binary_dump_cmdlist, "dump binary ", all_commands, gdb_stdout);
 670 }
 671
 672 static void
 673 binary_append_command (char *cmd, int from_tty)
 674 {
 675   printf_unfiltered (_("\"append binary\" must be followed by a subcommand.\n"));
 676   help_list (binary_append_cmdlist, "append binary ", all_commands,
 677              gdb_stdout);
 678 }
 679
 680 extern initialize_file_ftype _initialize_cli_dump; /* -Wmissing-prototypes */
 681
 682 void
 683 _initialize_cli_dump (void)
 684 {
 685   struct cmd_list_element *c;
 686
 687   add_prefix_cmd ("dump", class_vars, dump_command,
 688                   _("Dump target code/data to a local file."),
 689                   &dump_cmdlist, "dump ",
 690                   0/*allow-unknown*/,
 691                   &cmdlist);
 692   add_prefix_cmd ("append", class_vars, append_command,
 693                   _("Append target code/data to a local file."),
 694                   &append_cmdlist, "append ",
 695                   0/*allow-unknown*/,
 696                   &cmdlist);
 697
 698   add_dump_command ("memory", dump_memory_command, "\
 699 Write contents of memory to a raw binary file.\n\
 700 Arguments are FILE START STOP.  Writes the contents of memory within the\n\
 701 range [START .. STOP) to the specified FILE in raw target ordered bytes.");
 702
 703   add_dump_command ("value", dump_value_command, "\
 704 Write the value of an expression to a raw binary file.\n\
 705 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION to\n\
 706 the specified FILE in raw target ordered bytes.");
 707
 708   add_prefix_cmd ("srec", all_commands, srec_dump_command,
 709                   _("Write target code/data to an srec file."),
 710                   &srec_cmdlist, "dump srec ",
 711                   0 /*allow-unknown*/,
 712                   &dump_cmdlist);
 713
 714   add_prefix_cmd ("ihex", all_commands, ihex_dump_command,
 715                   _("Write target code/data to an intel hex file."),
 716                   &ihex_cmdlist, "dump ihex ",
 717                   0 /*allow-unknown*/,
 718                   &dump_cmdlist);
 719
 720   add_prefix_cmd ("verilog", all_commands, verilog_dump_command,
 721                   _("Write target code/data to a verilog hex file."),
 722                   &verilog_cmdlist, "dump verilog ",
 723                   0 /*allow-unknown*/,
 724                   &dump_cmdlist);
 725
 726   add_prefix_cmd ("tekhex", all_commands, tekhex_dump_command,
 727                   _("Write target code/data to a tekhex file."),
 728                   &tekhex_cmdlist, "dump tekhex ",
 729                   0 /*allow-unknown*/,
 730                   &dump_cmdlist);
 731
 732   add_prefix_cmd ("binary", all_commands, binary_dump_command,
 733                   _("Write target code/data to a raw binary file."),
 734                   &binary_dump_cmdlist, "dump binary ",
 735                   0 /*allow-unknown*/,
 736                   &dump_cmdlist);
 737
 738   add_prefix_cmd ("binary", all_commands, binary_append_command,
 739                   _("Append target code/data to a raw binary file."),
 740                   &binary_append_cmdlist, "append binary ",
 741                   0 /*allow-unknown*/,
 742                   &append_cmdlist);
 743
 744   add_cmd ("memory", all_commands, dump_srec_memory, _("\
 745 Write contents of memory to an srec file.\n\
 746 Arguments are FILE START STOP.  Writes the contents of memory\n\
 747 within the range [START .. STOP) to the specified FILE in srec format."),
 748            &srec_cmdlist);
 749
 750   add_cmd ("value", all_commands, dump_srec_value, _("\
 751 Write the value of an expression to an srec file.\n\
 752 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 753 to the specified FILE in srec format."),
 754            &srec_cmdlist);
 755
 756   add_cmd ("memory", all_commands, dump_ihex_memory, _("\
 757 Write contents of memory to an ihex file.\n\
 758 Arguments are FILE START STOP.  Writes the contents of memory within\n\
 759 the range [START .. STOP) to the specified FILE in intel hex format."),
 760            &ihex_cmdlist);
 761
 762   add_cmd ("value", all_commands, dump_ihex_value, _("\
 763 Write the value of an expression to an ihex file.\n\
 764 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 765 to the specified FILE in intel hex format."),
 766            &ihex_cmdlist);
 767
 768   add_cmd ("memory", all_commands, dump_verilog_memory, _("\
 769 Write contents of memory to a verilog hex file.\n\
 770 Arguments are FILE START STOP.  Writes the contents of memory within\n\
 771 the range [START .. STOP) to the specified FILE in verilog hex format."),
 772            &verilog_cmdlist);
 773
 774   add_cmd ("value", all_commands, dump_verilog_value, _("\
 775 Write the value of an expression to a verilog hex file.\n\
 776 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 777 to the specified FILE in verilog hex format."),
 778            &verilog_cmdlist);
 779
 780   add_cmd ("memory", all_commands, dump_tekhex_memory, _("\
 781 Write contents of memory to a tekhex file.\n\
 782 Arguments are FILE START STOP.  Writes the contents of memory\n\
 783 within the range [START .. STOP) to the specified FILE in tekhex format."),
 784            &tekhex_cmdlist);
 785
 786   add_cmd ("value", all_commands, dump_tekhex_value, _("\
 787 Write the value of an expression to a tekhex file.\n\
 788 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 789 to the specified FILE in tekhex format."),
 790            &tekhex_cmdlist);
 791
 792   add_cmd ("memory", all_commands, dump_binary_memory, _("\
 793 Write contents of memory to a raw binary file.\n\
 794 Arguments are FILE START STOP.  Writes the contents of memory\n\
 795 within the range [START .. STOP) to the specified FILE in binary format."),
 796            &binary_dump_cmdlist);
 797
 798   add_cmd ("value", all_commands, dump_binary_value, _("\
 799 Write the value of an expression to a raw binary file.\n\
 800 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 801 to the specified FILE in raw target ordered bytes."),
 802            &binary_dump_cmdlist);
 803
 804   add_cmd ("memory", all_commands, append_binary_memory, _("\
 805 Append contents of memory to a raw binary file.\n\
 806 Arguments are FILE START STOP.  Writes the contents of memory within the\n\
 807 range [START .. STOP) to the specified FILE in raw target ordered bytes."),
 808            &binary_append_cmdlist);
 809
 810   add_cmd ("value", all_commands, append_binary_value, _("\
 811 Append the value of an expression to a raw binary file.\n\
 812 Arguments are FILE EXPRESSION.  Writes the value of EXPRESSION\n\
 813 to the specified FILE in raw target ordered bytes."),
 814            &binary_append_cmdlist);
 815
 816   c = add_com ("restore", class_vars, restore_command, _("\
 817 Restore the contents of FILE to target memory.\n\
 818 Arguments are FILE OFFSET START END where all except FILE are optional.\n\
 819 OFFSET will be added to the base address of the file (default zero).\n\
 820 If START and END are given, only the file contents within that range\n\
 821 (file relative) will be restored to target memory."));
 822   c->completer = filename_completer;
 823   /* FIXME: completers for other commands.  */
 824 }