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