gdb/cli/cli-dump.c

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