1/* MI Command Set. 2 3 Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, 4 Inc. 5 6 Contributed by Cygnus Solutions (a Red Hat company). 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 59 Temple Place - Suite 330, 23 Boston, MA 02111-1307, USA. */ 24 25/* Work in progress */ 26 27#include "defs.h" 28#include "target.h" 29#include "inferior.h" 30#include "gdb_string.h" 31#include "top.h" 32#include "gdbthread.h" 33#include "mi-cmds.h" 34#include "mi-parse.h" 35#include "mi-getopt.h" 36#include "mi-console.h" 37#include "ui-out.h" 38#include "mi-out.h" 39#include "interps.h" 40#include "event-loop.h" 41#include "event-top.h" 42#include "gdbcore.h" /* for write_memory() */ 43#include "value.h" /* for deprecated_write_register_bytes() */ 44#include "regcache.h" 45#include "gdb.h" 46#include "frame.h" 47#include "mi-main.h" 48 49#include <ctype.h> 50#include <sys/time.h> 51 52enum 53 { 54 FROM_TTY = 0 55 }; 56 57/* Enumerations of the actions that may result from calling 58 captured_mi_execute_command */ 59 60enum captured_mi_execute_command_actions 61 { 62 EXECUTE_COMMAND_DISPLAY_PROMPT, 63 EXECUTE_COMMAND_SUPRESS_PROMPT, 64 EXECUTE_COMMAND_DISPLAY_ERROR 65 }; 66 67/* This structure is used to pass information from captured_mi_execute_command 68 to mi_execute_command. */ 69struct captured_mi_execute_command_args 70{ 71 /* This return result of the MI command (output) */ 72 enum mi_cmd_result rc; 73 74 /* What action to perform when the call is finished (output) */ 75 enum captured_mi_execute_command_actions action; 76 77 /* The command context to be executed (input) */ 78 struct mi_parse *command; 79}; 80 81int mi_debug_p; 82struct ui_file *raw_stdout; 83 84/* The token of the last asynchronous command */ 85static char *last_async_command; 86static char *previous_async_command; 87char *mi_error_message; 88static char *old_regs; 89 90extern void _initialize_mi_main (void); 91static enum mi_cmd_result mi_cmd_execute (struct mi_parse *parse); 92 93static void mi_execute_cli_command (const char *cmd, int args_p, 94 const char *args); 95static enum mi_cmd_result mi_execute_async_cli_command (char *mi, char *args, int from_tty); 96 97static void mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg); 98 99static int register_changed_p (int regnum); 100static int get_register (int regnum, int format); 101 102/* A helper function which will set mi_error_message to 103 error_last_message. */ 104void 105mi_error_last_message (void) 106{ 107 char *s = error_last_message (); 108 xasprintf (&mi_error_message, "%s", s); 109 xfree (s); 110} 111 112/* Command implementations. FIXME: Is this libgdb? No. This is the MI 113 layer that calls libgdb. Any operation used in the below should be 114 formalized. */ 115 116enum mi_cmd_result 117mi_cmd_gdb_exit (char *command, char **argv, int argc) 118{ 119 /* We have to print everything right here because we never return */ 120 if (last_async_command) 121 fputs_unfiltered (last_async_command, raw_stdout); 122 fputs_unfiltered ("^exit\n", raw_stdout); 123 mi_out_put (uiout, raw_stdout); 124 /* FIXME: The function called is not yet a formal libgdb function */ 125 quit_force (NULL, FROM_TTY); 126 return MI_CMD_DONE; 127} 128 129enum mi_cmd_result 130mi_cmd_exec_run (char *args, int from_tty) 131{ 132 /* FIXME: Should call a libgdb function, not a cli wrapper */ 133 return mi_execute_async_cli_command ("run", args, from_tty); 134} 135 136enum mi_cmd_result 137mi_cmd_exec_next (char *args, int from_tty) 138{ 139 /* FIXME: Should call a libgdb function, not a cli wrapper */ 140 return mi_execute_async_cli_command ("next", args, from_tty); 141} 142 143enum mi_cmd_result 144mi_cmd_exec_next_instruction (char *args, int from_tty) 145{ 146 /* FIXME: Should call a libgdb function, not a cli wrapper */ 147 return mi_execute_async_cli_command ("nexti", args, from_tty); 148} 149 150enum mi_cmd_result 151mi_cmd_exec_step (char *args, int from_tty) 152{ 153 /* FIXME: Should call a libgdb function, not a cli wrapper */ 154 return mi_execute_async_cli_command ("step", args, from_tty); 155} 156 157enum mi_cmd_result 158mi_cmd_exec_step_instruction (char *args, int from_tty) 159{ 160 /* FIXME: Should call a libgdb function, not a cli wrapper */ 161 return mi_execute_async_cli_command ("stepi", args, from_tty); 162} 163 164enum mi_cmd_result 165mi_cmd_exec_finish (char *args, int from_tty) 166{ 167 /* FIXME: Should call a libgdb function, not a cli wrapper */ 168 return mi_execute_async_cli_command ("finish", args, from_tty); 169} 170 171enum mi_cmd_result 172mi_cmd_exec_until (char *args, int from_tty) 173{ 174 /* FIXME: Should call a libgdb function, not a cli wrapper */ 175 return mi_execute_async_cli_command ("until", args, from_tty); 176} 177 178enum mi_cmd_result 179mi_cmd_exec_return (char *args, int from_tty) 180{ 181 /* This command doesn't really execute the target, it just pops the 182 specified number of frames. */ 183 if (*args) 184 /* Call return_command with from_tty argument equal to 0 so as to 185 avoid being queried. */ 186 return_command (args, 0); 187 else 188 /* Call return_command with from_tty argument equal to 0 so as to 189 avoid being queried. */ 190 return_command (NULL, 0); 191 192 /* Because we have called return_command with from_tty = 0, we need 193 to print the frame here. */ 194 print_stack_frame (deprecated_selected_frame, 195 frame_relative_level (deprecated_selected_frame), 196 LOC_AND_ADDRESS); 197 198 return MI_CMD_DONE; 199} 200 201enum mi_cmd_result 202mi_cmd_exec_continue (char *args, int from_tty) 203{ 204 /* FIXME: Should call a libgdb function, not a cli wrapper */ 205 return mi_execute_async_cli_command ("continue", args, from_tty); 206} 207 208/* Interrupt the execution of the target. Note how we must play around 209 with the token varialbes, in order to display the current token in 210 the result of the interrupt command, and the previous execution 211 token when the target finally stops. See comments in 212 mi_cmd_execute. */ 213enum mi_cmd_result 214mi_cmd_exec_interrupt (char *args, int from_tty) 215{ 216 if (!target_executing) 217 { 218 xasprintf (&mi_error_message, 219 "mi_cmd_exec_interrupt: Inferior not executing."); 220 return MI_CMD_ERROR; 221 } 222 interrupt_target_command (args, from_tty); 223 if (last_async_command) 224 fputs_unfiltered (last_async_command, raw_stdout); 225 fputs_unfiltered ("^done", raw_stdout); 226 xfree (last_async_command); 227 if (previous_async_command) 228 last_async_command = xstrdup (previous_async_command); 229 xfree (previous_async_command); 230 previous_async_command = NULL; 231 mi_out_put (uiout, raw_stdout); 232 mi_out_rewind (uiout); 233 fputs_unfiltered ("\n", raw_stdout); 234 return MI_CMD_QUIET; 235} 236 237enum mi_cmd_result 238mi_cmd_thread_select (char *command, char **argv, int argc) 239{ 240 enum gdb_rc rc; 241 242 if (argc != 1) 243 { 244 xasprintf (&mi_error_message, 245 "mi_cmd_thread_select: USAGE: threadnum."); 246 return MI_CMD_ERROR; 247 } 248 else 249 rc = gdb_thread_select (uiout, argv[0]); 250 251 /* RC is enum gdb_rc if it is successful (>=0) 252 enum return_reason if not (<0). */ 253 if ((int) rc < 0 && (enum return_reason) rc == RETURN_ERROR) 254 return MI_CMD_CAUGHT_ERROR; 255 else if ((int) rc >= 0 && rc == GDB_RC_FAIL) 256 return MI_CMD_ERROR; 257 else 258 return MI_CMD_DONE; 259} 260 261enum mi_cmd_result 262mi_cmd_thread_list_ids (char *command, char **argv, int argc) 263{ 264 enum gdb_rc rc = MI_CMD_DONE; 265 266 if (argc != 0) 267 { 268 xasprintf (&mi_error_message, 269 "mi_cmd_thread_list_ids: No arguments required."); 270 return MI_CMD_ERROR; 271 } 272 else 273 rc = gdb_list_thread_ids (uiout); 274 275 if (rc == GDB_RC_FAIL) 276 return MI_CMD_CAUGHT_ERROR; 277 else 278 return MI_CMD_DONE; 279} 280 281enum mi_cmd_result 282mi_cmd_data_list_register_names (char *command, char **argv, int argc) 283{ 284 int regnum, numregs; 285 int i; 286 struct cleanup *cleanup; 287 288 /* Note that the test for a valid register must include checking the 289 REGISTER_NAME because NUM_REGS may be allocated for the union of 290 the register sets within a family of related processors. In this 291 case, some entries of REGISTER_NAME will change depending upon 292 the particular processor being debugged. */ 293 294 numregs = NUM_REGS + NUM_PSEUDO_REGS; 295 296 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names"); 297 298 if (argc == 0) /* No args, just do all the regs */ 299 { 300 for (regnum = 0; 301 regnum < numregs; 302 regnum++) 303 { 304 if (REGISTER_NAME (regnum) == NULL 305 || *(REGISTER_NAME (regnum)) == '\0') 306 ui_out_field_string (uiout, NULL, ""); 307 else 308 ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum)); 309 } 310 } 311 312 /* Else, list of register #s, just do listed regs */ 313 for (i = 0; i < argc; i++) 314 { 315 regnum = atoi (argv[i]); 316 if (regnum < 0 || regnum >= numregs) 317 { 318 do_cleanups (cleanup); 319 xasprintf (&mi_error_message, "bad register number"); 320 return MI_CMD_ERROR; 321 } 322 if (REGISTER_NAME (regnum) == NULL 323 || *(REGISTER_NAME (regnum)) == '\0') 324 ui_out_field_string (uiout, NULL, ""); 325 else 326 ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum)); 327 } 328 do_cleanups (cleanup); 329 return MI_CMD_DONE; 330} 331 332enum mi_cmd_result 333mi_cmd_data_list_changed_registers (char *command, char **argv, int argc) 334{ 335 int regnum, numregs, changed; 336 int i; 337 struct cleanup *cleanup; 338 339 /* Note that the test for a valid register must include checking the 340 REGISTER_NAME because NUM_REGS may be allocated for the union of 341 the register sets within a family of related processors. In this 342 case, some entries of REGISTER_NAME will change depending upon 343 the particular processor being debugged. */ 344 345 numregs = NUM_REGS; 346 347 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changed-registers"); 348 349 if (argc == 0) /* No args, just do all the regs */ 350 { 351 for (regnum = 0; 352 regnum < numregs; 353 regnum++) 354 { 355 if (REGISTER_NAME (regnum) == NULL 356 || *(REGISTER_NAME (regnum)) == '\0') 357 continue; 358 changed = register_changed_p (regnum); 359 if (changed < 0) 360 { 361 do_cleanups (cleanup); 362 xasprintf (&mi_error_message, 363 "mi_cmd_data_list_changed_registers: Unable to read register contents."); 364 return MI_CMD_ERROR; 365 } 366 else if (changed) 367 ui_out_field_int (uiout, NULL, regnum); 368 } 369 } 370 371 /* Else, list of register #s, just do listed regs */ 372 for (i = 0; i < argc; i++) 373 { 374 regnum = atoi (argv[i]); 375 376 if (regnum >= 0 377 && regnum < numregs 378 && REGISTER_NAME (regnum) != NULL 379 && *REGISTER_NAME (regnum) != '\000') 380 { 381 changed = register_changed_p (regnum); 382 if (changed < 0) 383 { 384 do_cleanups (cleanup); 385 xasprintf (&mi_error_message, 386 "mi_cmd_data_list_register_change: Unable to read register contents."); 387 return MI_CMD_ERROR; 388 } 389 else if (changed) 390 ui_out_field_int (uiout, NULL, regnum); 391 } 392 else 393 { 394 do_cleanups (cleanup); 395 xasprintf (&mi_error_message, "bad register number"); 396 return MI_CMD_ERROR; 397 } 398 } 399 do_cleanups (cleanup); 400 return MI_CMD_DONE; 401} 402 403static int 404register_changed_p (int regnum) 405{ 406 char raw_buffer[MAX_REGISTER_SIZE]; 407 408 if (! frame_register_read (deprecated_selected_frame, regnum, raw_buffer)) 409 return -1; 410 411 if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer, 412 DEPRECATED_REGISTER_RAW_SIZE (regnum)) == 0) 413 return 0; 414 415 /* Found a changed register. Return 1. */ 416 417 memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer, 418 DEPRECATED_REGISTER_RAW_SIZE (regnum)); 419 420 return 1; 421} 422 423/* Return a list of register number and value pairs. The valid 424 arguments expected are: a letter indicating the format in which to 425 display the registers contents. This can be one of: x (hexadecimal), d 426 (decimal), N (natural), t (binary), o (octal), r (raw). After the 427 format argumetn there can be a sequence of numbers, indicating which 428 registers to fetch the content of. If the format is the only argument, 429 a list of all the registers with their values is returned. */ 430enum mi_cmd_result 431mi_cmd_data_list_register_values (char *command, char **argv, int argc) 432{ 433 int regnum, numregs, format, result; 434 int i; 435 struct cleanup *list_cleanup, *tuple_cleanup; 436 437 /* Note that the test for a valid register must include checking the 438 REGISTER_NAME because NUM_REGS may be allocated for the union of 439 the register sets within a family of related processors. In this 440 case, some entries of REGISTER_NAME will change depending upon 441 the particular processor being debugged. */ 442 443 numregs = NUM_REGS; 444 445 if (argc == 0) 446 { 447 xasprintf (&mi_error_message, 448 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]"); 449 return MI_CMD_ERROR; 450 } 451 452 format = (int) argv[0][0]; 453 454 if (!target_has_registers) 455 { 456 xasprintf (&mi_error_message, 457 "mi_cmd_data_list_register_values: No registers."); 458 return MI_CMD_ERROR; 459 } 460 461 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values"); 462 463 if (argc == 1) /* No args, beside the format: do all the regs */ 464 { 465 for (regnum = 0; 466 regnum < numregs; 467 regnum++) 468 { 469 if (REGISTER_NAME (regnum) == NULL 470 || *(REGISTER_NAME (regnum)) == '\0') 471 continue; 472 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 473 ui_out_field_int (uiout, "number", regnum); 474 result = get_register (regnum, format); 475 if (result == -1) 476 { 477 do_cleanups (list_cleanup); 478 return MI_CMD_ERROR; 479 } 480 do_cleanups (tuple_cleanup); 481 } 482 } 483 484 /* Else, list of register #s, just do listed regs */ 485 for (i = 1; i < argc; i++) 486 { 487 regnum = atoi (argv[i]); 488 489 if (regnum >= 0 490 && regnum < numregs 491 && REGISTER_NAME (regnum) != NULL 492 && *REGISTER_NAME (regnum) != '\000') 493 { 494 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 495 ui_out_field_int (uiout, "number", regnum); 496 result = get_register (regnum, format); 497 if (result == -1) 498 { 499 do_cleanups (list_cleanup); 500 return MI_CMD_ERROR; 501 } 502 do_cleanups (tuple_cleanup); 503 } 504 else 505 { 506 do_cleanups (list_cleanup); 507 xasprintf (&mi_error_message, "bad register number"); 508 return MI_CMD_ERROR; 509 } 510 } 511 do_cleanups (list_cleanup); 512 return MI_CMD_DONE; 513} 514 515/* Output one register's contents in the desired format. */ 516static int 517get_register (int regnum, int format) 518{ 519 char raw_buffer[MAX_REGISTER_SIZE]; 520 char virtual_buffer[MAX_REGISTER_SIZE]; 521 int optim; 522 int realnum; 523 CORE_ADDR addr; 524 enum lval_type lval; 525 static struct ui_stream *stb = NULL; 526 527 stb = ui_out_stream_new (uiout); 528 529 if (format == 'N') 530 format = 0; 531 532 frame_register (deprecated_selected_frame, regnum, &optim, &lval, &addr, 533 &realnum, raw_buffer); 534 535 if (optim) 536 { 537 xasprintf (&mi_error_message, "Optimized out"); 538 return -1; 539 } 540 541 /* Convert raw data to virtual format if necessary. */ 542 543 if (DEPRECATED_REGISTER_CONVERTIBLE_P () 544 && DEPRECATED_REGISTER_CONVERTIBLE (regnum)) 545 { 546 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, 547 register_type (current_gdbarch, regnum), 548 raw_buffer, virtual_buffer); 549 } 550 else 551 memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)); 552 553 if (format == 'r') 554 { 555 int j; 556 char *ptr, buf[1024]; 557 558 strcpy (buf, "0x"); 559 ptr = buf + 2; 560 for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (regnum); j++) 561 { 562 int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j 563 : DEPRECATED_REGISTER_RAW_SIZE (regnum) - 1 - j; 564 sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]); 565 ptr += 2; 566 } 567 ui_out_field_string (uiout, "value", buf); 568 /*fputs_filtered (buf, gdb_stdout); */ 569 } 570 else 571 { 572 val_print (register_type (current_gdbarch, regnum), virtual_buffer, 0, 0, 573 stb->stream, format, 1, 0, Val_pretty_default); 574 ui_out_field_stream (uiout, "value", stb); 575 ui_out_stream_delete (stb); 576 } 577 return 1; 578} 579 580/* Write given values into registers. The registers and values are 581 given as pairs. The corresponding MI command is 582 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/ 583enum mi_cmd_result 584mi_cmd_data_write_register_values (char *command, char **argv, int argc) 585{ 586 int regnum; 587 int i; 588 int numregs; 589 LONGEST value; 590 char format; 591 592 /* Note that the test for a valid register must include checking the 593 REGISTER_NAME because NUM_REGS may be allocated for the union of 594 the register sets within a family of related processors. In this 595 case, some entries of REGISTER_NAME will change depending upon 596 the particular processor being debugged. */ 597 598 numregs = NUM_REGS; 599 600 if (argc == 0) 601 { 602 xasprintf (&mi_error_message, 603 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]"); 604 return MI_CMD_ERROR; 605 } 606 607 format = (int) argv[0][0]; 608 609 if (!target_has_registers) 610 { 611 xasprintf (&mi_error_message, 612 "mi_cmd_data_write_register_values: No registers."); 613 return MI_CMD_ERROR; 614 } 615 616 if (!(argc - 1)) 617 { 618 xasprintf (&mi_error_message, 619 "mi_cmd_data_write_register_values: No regs and values specified."); 620 return MI_CMD_ERROR; 621 } 622 623 if ((argc - 1) % 2) 624 { 625 xasprintf (&mi_error_message, 626 "mi_cmd_data_write_register_values: Regs and vals are not in pairs."); 627 return MI_CMD_ERROR; 628 } 629 630 for (i = 1; i < argc; i = i + 2) 631 { 632 regnum = atoi (argv[i]); 633 634 if (regnum >= 0 635 && regnum < numregs 636 && REGISTER_NAME (regnum) != NULL 637 && *REGISTER_NAME (regnum) != '\000') 638 { 639 void *buffer; 640 struct cleanup *old_chain; 641 642 /* Get the value as a number */ 643 value = parse_and_eval_address (argv[i + 1]); 644 /* Get the value into an array */ 645 buffer = xmalloc (DEPRECATED_REGISTER_SIZE); 646 old_chain = make_cleanup (xfree, buffer); 647 store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value); 648 /* Write it down */ 649 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum)); 650 /* Free the buffer. */ 651 do_cleanups (old_chain); 652 } 653 else 654 { 655 xasprintf (&mi_error_message, "bad register number"); 656 return MI_CMD_ERROR; 657 } 658 } 659 return MI_CMD_DONE; 660} 661 662#if 0 663/*This is commented out because we decided it was not useful. I leave 664 it, just in case. ezannoni:1999-12-08 */ 665 666/* Assign a value to a variable. The expression argument must be in 667 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be 668 quoted. */ 669enum mi_cmd_result 670mi_cmd_data_assign (char *command, char **argv, int argc) 671{ 672 struct expression *expr; 673 struct cleanup *old_chain; 674 675 if (argc != 1) 676 { 677 xasprintf (&mi_error_message, 678 "mi_cmd_data_assign: Usage: -data-assign expression"); 679 return MI_CMD_ERROR; 680 } 681 682 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni 683 01-12-1999: Need to decide what to do with this for libgdb purposes. */ 684 685 expr = parse_expression (argv[0]); 686 old_chain = make_cleanup (free_current_contents, &expr); 687 evaluate_expression (expr); 688 do_cleanups (old_chain); 689 return MI_CMD_DONE; 690} 691#endif 692 693/* Evaluate the value of the argument. The argument is an 694 expression. If the expression contains spaces it needs to be 695 included in double quotes. */ 696enum mi_cmd_result 697mi_cmd_data_evaluate_expression (char *command, char **argv, int argc) 698{ 699 struct expression *expr; 700 struct cleanup *old_chain = NULL; 701 struct value *val; 702 struct ui_stream *stb = NULL; 703 704 stb = ui_out_stream_new (uiout); 705 706 if (argc != 1) 707 { 708 xasprintf (&mi_error_message, 709 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression"); 710 return MI_CMD_ERROR; 711 } 712 713 expr = parse_expression (argv[0]); 714 715 old_chain = make_cleanup (free_current_contents, &expr); 716 717 val = evaluate_expression (expr); 718 719 /* Print the result of the expression evaluation. */ 720 val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 721 VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val), 722 stb->stream, 0, 0, 0, 0); 723 724 ui_out_field_stream (uiout, "value", stb); 725 ui_out_stream_delete (stb); 726 727 do_cleanups (old_chain); 728 729 return MI_CMD_DONE; 730} 731 732enum mi_cmd_result 733mi_cmd_target_download (char *args, int from_tty) 734{ 735 char *run; 736 struct cleanup *old_cleanups = NULL; 737 738 xasprintf (&run, "load %s", args); 739 old_cleanups = make_cleanup (xfree, run); 740 execute_command (run, from_tty); 741 742 do_cleanups (old_cleanups); 743 return MI_CMD_DONE; 744} 745 746/* Connect to the remote target. */ 747enum mi_cmd_result 748mi_cmd_target_select (char *args, int from_tty) 749{ 750 char *run; 751 struct cleanup *old_cleanups = NULL; 752 753 xasprintf (&run, "target %s", args); 754 old_cleanups = make_cleanup (xfree, run); 755 756 /* target-select is always synchronous. once the call has returned 757 we know that we are connected. */ 758 /* NOTE: At present all targets that are connected are also 759 (implicitly) talking to a halted target. In the future this may 760 change. */ 761 execute_command (run, from_tty); 762 763 do_cleanups (old_cleanups); 764 765 /* Issue the completion message here. */ 766 if (last_async_command) 767 fputs_unfiltered (last_async_command, raw_stdout); 768 fputs_unfiltered ("^connected", raw_stdout); 769 mi_out_put (uiout, raw_stdout); 770 mi_out_rewind (uiout); 771 fputs_unfiltered ("\n", raw_stdout); 772 do_exec_cleanups (ALL_CLEANUPS); 773 return MI_CMD_QUIET; 774} 775 776/* DATA-MEMORY-READ: 777 778 ADDR: start address of data to be dumped. 779 WORD-FORMAT: a char indicating format for the ``word''. See 780 the ``x'' command. 781 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes 782 NR_ROW: Number of rows. 783 NR_COL: The number of colums (words per row). 784 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use 785 ASCHAR for unprintable characters. 786 787 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and 788 displayes them. Returns: 789 790 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...} 791 792 Returns: 793 The number of bytes read is SIZE*ROW*COL. */ 794 795enum mi_cmd_result 796mi_cmd_data_read_memory (char *command, char **argv, int argc) 797{ 798 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL); 799 CORE_ADDR addr; 800 long total_bytes; 801 long nr_cols; 802 long nr_rows; 803 char word_format; 804 struct type *word_type; 805 long word_size; 806 char word_asize; 807 char aschar; 808 char *mbuf; 809 int nr_bytes; 810 long offset = 0; 811 int optind = 0; 812 char *optarg; 813 enum opt 814 { 815 OFFSET_OPT 816 }; 817 static struct mi_opt opts[] = 818 { 819 {"o", OFFSET_OPT, 1}, 820 0 821 }; 822 823 while (1) 824 { 825 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts, 826 &optind, &optarg); 827 if (opt < 0) 828 break; 829 switch ((enum opt) opt) 830 { 831 case OFFSET_OPT: 832 offset = atol (optarg); 833 break; 834 } 835 } 836 argv += optind; 837 argc -= optind; 838 839 if (argc < 5 || argc > 6) 840 { 841 xasprintf (&mi_error_message, 842 "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."); 843 return MI_CMD_ERROR; 844 } 845 846 /* Extract all the arguments. */ 847 848 /* Start address of the memory dump. */ 849 addr = parse_and_eval_address (argv[0]) + offset; 850 /* The format character to use when displaying a memory word. See 851 the ``x'' command. */ 852 word_format = argv[1][0]; 853 /* The size of the memory word. */ 854 word_size = atol (argv[2]); 855 switch (word_size) 856 { 857 case 1: 858 word_type = builtin_type_int8; 859 word_asize = 'b'; 860 break; 861 case 2: 862 word_type = builtin_type_int16; 863 word_asize = 'h'; 864 break; 865 case 4: 866 word_type = builtin_type_int32; 867 word_asize = 'w'; 868 break; 869 case 8: 870 word_type = builtin_type_int64; 871 word_asize = 'g'; 872 break; 873 default: 874 word_type = builtin_type_int8; 875 word_asize = 'b'; 876 } 877 /* The number of rows */ 878 nr_rows = atol (argv[3]); 879 if (nr_rows <= 0) 880 { 881 xasprintf (&mi_error_message, 882 "mi_cmd_data_read_memory: invalid number of rows."); 883 return MI_CMD_ERROR; 884 } 885 /* number of bytes per row. */ 886 nr_cols = atol (argv[4]); 887 if (nr_cols <= 0) 888 { 889 xasprintf (&mi_error_message, 890 "mi_cmd_data_read_memory: invalid number of columns."); 891 } 892 /* The un-printable character when printing ascii. */ 893 if (argc == 6) 894 aschar = *argv[5]; 895 else 896 aschar = 0; 897 898 /* create a buffer and read it in. */ 899 total_bytes = word_size * nr_rows * nr_cols; 900 mbuf = xcalloc (total_bytes, 1); 901 make_cleanup (xfree, mbuf); 902 if (mbuf == NULL) 903 { 904 xasprintf (&mi_error_message, 905 "mi_cmd_data_read_memory: out of memory."); 906 return MI_CMD_ERROR; 907 } 908 nr_bytes = 0; 909 while (nr_bytes < total_bytes) 910 { 911 int error; 912 long num = target_read_memory_partial (addr + nr_bytes, mbuf + nr_bytes, 913 total_bytes - nr_bytes, 914 &error); 915 if (num <= 0) 916 break; 917 nr_bytes += num; 918 } 919 920 /* output the header information. */ 921 ui_out_field_core_addr (uiout, "addr", addr); 922 ui_out_field_int (uiout, "nr-bytes", nr_bytes); 923 ui_out_field_int (uiout, "total-bytes", total_bytes); 924 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols); 925 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols); 926 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes); 927 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes); 928 929 /* Build the result as a two dimentional table. */ 930 { 931 struct ui_stream *stream = ui_out_stream_new (uiout); 932 struct cleanup *cleanup_list_memory; 933 int row; 934 int row_byte; 935 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory"); 936 for (row = 0, row_byte = 0; 937 row < nr_rows; 938 row++, row_byte += nr_cols * word_size) 939 { 940 int col; 941 int col_byte; 942 struct cleanup *cleanup_tuple; 943 struct cleanup *cleanup_list_data; 944 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 945 ui_out_field_core_addr (uiout, "addr", addr + row_byte); 946 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */ 947 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data"); 948 for (col = 0, col_byte = row_byte; 949 col < nr_cols; 950 col++, col_byte += word_size) 951 { 952 if (col_byte + word_size > nr_bytes) 953 { 954 ui_out_field_string (uiout, NULL, "N/A"); 955 } 956 else 957 { 958 ui_file_rewind (stream->stream); 959 print_scalar_formatted (mbuf + col_byte, word_type, word_format, 960 word_asize, stream->stream); 961 ui_out_field_stream (uiout, NULL, stream); 962 } 963 } 964 do_cleanups (cleanup_list_data); 965 if (aschar) 966 { 967 int byte; 968 ui_file_rewind (stream->stream); 969 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++) 970 { 971 if (byte >= nr_bytes) 972 { 973 fputc_unfiltered ('X', stream->stream); 974 } 975 else if (mbuf[byte] < 32 || mbuf[byte] > 126) 976 { 977 fputc_unfiltered (aschar, stream->stream); 978 } 979 else 980 fputc_unfiltered (mbuf[byte], stream->stream); 981 } 982 ui_out_field_stream (uiout, "ascii", stream); 983 } 984 do_cleanups (cleanup_tuple); 985 } 986 ui_out_stream_delete (stream); 987 do_cleanups (cleanup_list_memory); 988 } 989 do_cleanups (cleanups); 990 return MI_CMD_DONE; 991} 992 993/* DATA-MEMORY-WRITE: 994 995 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The 996 offset from the beginning of the memory grid row where the cell to 997 be written is. 998 ADDR: start address of the row in the memory grid where the memory 999 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of 1000 the location to write to. 1001 FORMAT: a char indicating format for the ``word''. See 1002 the ``x'' command. 1003 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes 1004 VALUE: value to be written into the memory address. 1005 1006 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE). 1007 1008 Prints nothing. */ 1009enum mi_cmd_result 1010mi_cmd_data_write_memory (char *command, char **argv, int argc) 1011{ 1012 CORE_ADDR addr; 1013 char word_format; 1014 long word_size; 1015 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big 1016 enough when using a compiler other than GCC. */ 1017 LONGEST value; 1018 void *buffer; 1019 struct cleanup *old_chain; 1020 long offset = 0; 1021 int optind = 0; 1022 char *optarg; 1023 enum opt 1024 { 1025 OFFSET_OPT 1026 }; 1027 static struct mi_opt opts[] = 1028 { 1029 {"o", OFFSET_OPT, 1}, 1030 0 1031 }; 1032 1033 while (1) 1034 { 1035 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts, 1036 &optind, &optarg); 1037 if (opt < 0) 1038 break; 1039 switch ((enum opt) opt) 1040 { 1041 case OFFSET_OPT: 1042 offset = atol (optarg); 1043 break; 1044 } 1045 } 1046 argv += optind; 1047 argc -= optind; 1048 1049 if (argc != 4) 1050 { 1051 xasprintf (&mi_error_message, 1052 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."); 1053 return MI_CMD_ERROR; 1054 } 1055 1056 /* Extract all the arguments. */ 1057 /* Start address of the memory dump. */ 1058 addr = parse_and_eval_address (argv[0]); 1059 /* The format character to use when displaying a memory word. See 1060 the ``x'' command. */ 1061 word_format = argv[1][0]; 1062 /* The size of the memory word. */ 1063 word_size = atol (argv[2]); 1064 1065 /* Calculate the real address of the write destination. */ 1066 addr += (offset * word_size); 1067 1068 /* Get the value as a number */ 1069 value = parse_and_eval_address (argv[3]); 1070 /* Get the value into an array */ 1071 buffer = xmalloc (word_size); 1072 old_chain = make_cleanup (xfree, buffer); 1073 store_signed_integer (buffer, word_size, value); 1074 /* Write it down to memory */ 1075 write_memory (addr, buffer, word_size); 1076 /* Free the buffer. */ 1077 do_cleanups (old_chain); 1078 1079 return MI_CMD_DONE; 1080} 1081 1082/* Execute a command within a safe environment. 1083 Return <0 for error; >=0 for ok. 1084 1085 args->action will tell mi_execute_command what action 1086 to perfrom after the given command has executed (display/supress 1087 prompt, display error). */ 1088 1089static int 1090captured_mi_execute_command (struct ui_out *uiout, void *data) 1091{ 1092 struct captured_mi_execute_command_args *args = 1093 (struct captured_mi_execute_command_args *) data; 1094 struct mi_parse *context = args->command; 1095 1096 switch (context->op) 1097 { 1098 1099 case MI_COMMAND: 1100 /* A MI command was read from the input stream */ 1101 if (mi_debug_p) 1102 /* FIXME: gdb_???? */ 1103 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n", 1104 context->token, context->command, context->args); 1105 /* FIXME: cagney/1999-09-25: Rather than this convoluted 1106 condition expression, each function should return an 1107 indication of what action is required and then switch on 1108 that. */ 1109 args->action = EXECUTE_COMMAND_DISPLAY_PROMPT; 1110 args->rc = mi_cmd_execute (context); 1111 1112 if (!target_can_async_p () || !target_executing) 1113 { 1114 /* print the result if there were no errors 1115 1116 Remember that on the way out of executing a command, you have 1117 to directly use the mi_interp's uiout, since the command could 1118 have reset the interpreter, in which case the current uiout 1119 will most likely crash in the mi_out_* routines. */ 1120 if (args->rc == MI_CMD_DONE) 1121 { 1122 fputs_unfiltered (context->token, raw_stdout); 1123 fputs_unfiltered ("^done", raw_stdout); 1124 mi_out_put (uiout, raw_stdout); 1125 mi_out_rewind (uiout); 1126 fputs_unfiltered ("\n", raw_stdout); 1127 } 1128 else if (args->rc == MI_CMD_ERROR) 1129 { 1130 if (mi_error_message) 1131 { 1132 fputs_unfiltered (context->token, raw_stdout); 1133 fputs_unfiltered ("^error,msg=\"", raw_stdout); 1134 fputstr_unfiltered (mi_error_message, '"', raw_stdout); 1135 xfree (mi_error_message); 1136 fputs_unfiltered ("\"\n", raw_stdout); 1137 } 1138 mi_out_rewind (uiout); 1139 } 1140 else if (args->rc == MI_CMD_CAUGHT_ERROR) 1141 { 1142 mi_out_rewind (uiout); 1143 args->action = EXECUTE_COMMAND_DISPLAY_ERROR; 1144 return 1; 1145 } 1146 else 1147 mi_out_rewind (uiout); 1148 } 1149 else if (sync_execution) 1150 { 1151 /* Don't print the prompt. We are executing the target in 1152 synchronous mode. */ 1153 args->action = EXECUTE_COMMAND_SUPRESS_PROMPT; 1154 return 1; 1155 } 1156 break; 1157 1158 case CLI_COMMAND: 1159 /* A CLI command was read from the input stream */ 1160 /* This will be removed as soon as we have a complete set of 1161 mi commands */ 1162 /* echo the command on the console. */ 1163 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command); 1164 mi_execute_cli_command (context->command, 0, NULL); 1165 1166 /* If we changed interpreters, DON'T print out anything. */ 1167 if (current_interp_named_p (INTERP_MI) 1168 || current_interp_named_p (INTERP_MI1) 1169 || current_interp_named_p (INTERP_MI2) 1170 || current_interp_named_p (INTERP_MI3)) 1171 { 1172 /* print the result */ 1173 /* FIXME: Check for errors here. */ 1174 fputs_unfiltered (context->token, raw_stdout); 1175 fputs_unfiltered ("^done", raw_stdout); 1176 mi_out_put (uiout, raw_stdout); 1177 mi_out_rewind (uiout); 1178 fputs_unfiltered ("\n", raw_stdout); 1179 args->action = EXECUTE_COMMAND_DISPLAY_PROMPT; 1180 args->rc = MI_CMD_DONE; 1181 } 1182 break; 1183 1184 } 1185 1186 return 1; 1187} 1188 1189 1190void 1191mi_execute_command (char *cmd, int from_tty) 1192{ 1193 struct mi_parse *command; 1194 struct captured_mi_execute_command_args args; 1195 struct ui_out *saved_uiout = uiout; 1196 int result; 1197 1198 /* This is to handle EOF (^D). We just quit gdb. */ 1199 /* FIXME: we should call some API function here. */ 1200 if (cmd == 0) 1201 quit_force (NULL, from_tty); 1202 1203 command = mi_parse (cmd); 1204 1205 if (command != NULL) 1206 { 1207 /* FIXME: cagney/1999-11-04: Can this use of catch_exceptions either 1208 be pushed even further down or even eliminated? */ 1209 args.command = command; 1210 result = catch_exceptions (uiout, captured_mi_execute_command, &args, "", 1211 RETURN_MASK_ALL); 1212 1213 if (args.action == EXECUTE_COMMAND_SUPRESS_PROMPT) 1214 { 1215 /* The command is executing synchronously. Bail out early 1216 suppressing the finished prompt. */ 1217 mi_parse_free (command); 1218 return; 1219 } 1220 if (args.action == EXECUTE_COMMAND_DISPLAY_ERROR || result < 0) 1221 { 1222 char *msg = error_last_message (); 1223 struct cleanup *cleanup = make_cleanup (xfree, msg); 1224 /* The command execution failed and error() was called 1225 somewhere */ 1226 fputs_unfiltered (command->token, raw_stdout); 1227 fputs_unfiltered ("^error,msg=\"", raw_stdout); 1228 fputstr_unfiltered (msg, '"', raw_stdout); 1229 fputs_unfiltered ("\"\n", raw_stdout); 1230 } 1231 mi_parse_free (command); 1232 } 1233 1234 fputs_unfiltered ("(gdb) \n", raw_stdout); 1235 gdb_flush (raw_stdout); 1236 /* print any buffered hook code */ 1237 /* ..... */ 1238} 1239 1240static enum mi_cmd_result 1241mi_cmd_execute (struct mi_parse *parse) 1242{ 1243 if (parse->cmd->argv_func != NULL 1244 || parse->cmd->args_func != NULL) 1245 { 1246 /* FIXME: We need to save the token because the command executed 1247 may be asynchronous and need to print the token again. 1248 In the future we can pass the token down to the func 1249 and get rid of the last_async_command */ 1250 /* The problem here is to keep the token around when we launch 1251 the target, and we want to interrupt it later on. The 1252 interrupt command will have its own token, but when the 1253 target stops, we must display the token corresponding to the 1254 last execution command given. So we have another string where 1255 we copy the token (previous_async_command), if this was 1256 indeed the token of an execution command, and when we stop we 1257 print that one. This is possible because the interrupt 1258 command, when over, will copy that token back into the 1259 default token string (last_async_command). */ 1260 1261 if (target_executing) 1262 { 1263 if (!previous_async_command) 1264 previous_async_command = xstrdup (last_async_command); 1265 if (strcmp (parse->command, "exec-interrupt")) 1266 { 1267 fputs_unfiltered (parse->token, raw_stdout); 1268 fputs_unfiltered ("^error,msg=\"", raw_stdout); 1269 fputs_unfiltered ("Cannot execute command ", raw_stdout); 1270 fputstr_unfiltered (parse->command, '"', raw_stdout); 1271 fputs_unfiltered (" while target running", raw_stdout); 1272 fputs_unfiltered ("\"\n", raw_stdout); 1273 return MI_CMD_ERROR; 1274 } 1275 } 1276 last_async_command = xstrdup (parse->token); 1277 make_exec_cleanup (free_current_contents, &last_async_command); 1278 /* FIXME: DELETE THIS! */ 1279 if (parse->cmd->args_func != NULL) 1280 return parse->cmd->args_func (parse->args, 0 /*from_tty */ ); 1281 return parse->cmd->argv_func (parse->command, parse->argv, parse->argc); 1282 } 1283 else if (parse->cmd->cli.cmd != 0) 1284 { 1285 /* FIXME: DELETE THIS. */ 1286 /* The operation is still implemented by a cli command */ 1287 /* Must be a synchronous one */ 1288 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p, 1289 parse->args); 1290 return MI_CMD_DONE; 1291 } 1292 else 1293 { 1294 /* FIXME: DELETE THIS. */ 1295 fputs_unfiltered (parse->token, raw_stdout); 1296 fputs_unfiltered ("^error,msg=\"", raw_stdout); 1297 fputs_unfiltered ("Undefined mi command: ", raw_stdout); 1298 fputstr_unfiltered (parse->command, '"', raw_stdout); 1299 fputs_unfiltered (" (missing implementation)", raw_stdout); 1300 fputs_unfiltered ("\"\n", raw_stdout); 1301 return MI_CMD_ERROR; 1302 } 1303} 1304 1305/* FIXME: This is just a hack so we can get some extra commands going. 1306 We don't want to channel things through the CLI, but call libgdb directly */ 1307/* Use only for synchronous commands */ 1308 1309void 1310mi_execute_cli_command (const char *cmd, int args_p, const char *args) 1311{ 1312 if (cmd != 0) 1313 { 1314 struct cleanup *old_cleanups; 1315 char *run; 1316 if (args_p) 1317 xasprintf (&run, "%s %s", cmd, args); 1318 else 1319 run = xstrdup (cmd); 1320 if (mi_debug_p) 1321 /* FIXME: gdb_???? */ 1322 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n", 1323 cmd, run); 1324 old_cleanups = make_cleanup (xfree, run); 1325 execute_command ( /*ui */ run, 0 /*from_tty */ ); 1326 do_cleanups (old_cleanups); 1327 return; 1328 } 1329} 1330 1331enum mi_cmd_result 1332mi_execute_async_cli_command (char *mi, char *args, int from_tty) 1333{ 1334 struct cleanup *old_cleanups; 1335 char *run; 1336 char *async_args; 1337 1338 if (target_can_async_p ()) 1339 { 1340 async_args = (char *) xmalloc (strlen (args) + 2); 1341 make_exec_cleanup (free, async_args); 1342 strcpy (async_args, args); 1343 strcat (async_args, "&"); 1344 xasprintf (&run, "%s %s", mi, async_args); 1345 make_exec_cleanup (free, run); 1346 add_continuation (mi_exec_async_cli_cmd_continuation, NULL); 1347 old_cleanups = NULL; 1348 } 1349 else 1350 { 1351 xasprintf (&run, "%s %s", mi, args); 1352 old_cleanups = make_cleanup (xfree, run); 1353 } 1354 1355 if (!target_can_async_p ()) 1356 { 1357 /* NOTE: For synchronous targets asynchronous behavour is faked by 1358 printing out the GDB prompt before we even try to execute the 1359 command. */ 1360 if (last_async_command) 1361 fputs_unfiltered (last_async_command, raw_stdout); 1362 fputs_unfiltered ("^running\n", raw_stdout); 1363 fputs_unfiltered ("(gdb) \n", raw_stdout); 1364 gdb_flush (raw_stdout); 1365 } 1366 else 1367 { 1368 /* FIXME: cagney/1999-11-29: Printing this message before 1369 calling execute_command is wrong. It should only be printed 1370 once gdb has confirmed that it really has managed to send a 1371 run command to the target. */ 1372 if (last_async_command) 1373 fputs_unfiltered (last_async_command, raw_stdout); 1374 fputs_unfiltered ("^running\n", raw_stdout); 1375 } 1376 1377 execute_command ( /*ui */ run, 0 /*from_tty */ ); 1378 1379 if (!target_can_async_p ()) 1380 { 1381 /* Do this before doing any printing. It would appear that some 1382 print code leaves garbage around in the buffer. */ 1383 do_cleanups (old_cleanups); 1384 /* If the target was doing the operation synchronously we fake 1385 the stopped message. */ 1386 if (last_async_command) 1387 fputs_unfiltered (last_async_command, raw_stdout); 1388 fputs_unfiltered ("*stopped", raw_stdout); 1389 mi_out_put (uiout, raw_stdout); 1390 mi_out_rewind (uiout); 1391 fputs_unfiltered ("\n", raw_stdout); 1392 return MI_CMD_QUIET; 1393 } 1394 return MI_CMD_DONE; 1395} 1396 1397void 1398mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg) 1399{ 1400 if (last_async_command) 1401 fputs_unfiltered (last_async_command, raw_stdout); 1402 fputs_unfiltered ("*stopped", raw_stdout); 1403 mi_out_put (uiout, raw_stdout); 1404 fputs_unfiltered ("\n", raw_stdout); 1405 fputs_unfiltered ("(gdb) \n", raw_stdout); 1406 gdb_flush (raw_stdout); 1407 do_exec_cleanups (ALL_CLEANUPS); 1408} 1409 1410void 1411mi_load_progress (const char *section_name, 1412 unsigned long sent_so_far, 1413 unsigned long total_section, 1414 unsigned long total_sent, 1415 unsigned long grand_total) 1416{ 1417 struct timeval time_now, delta, update_threshold; 1418 static struct timeval last_update; 1419 static char *previous_sect_name = NULL; 1420 int new_section; 1421 1422 if (!current_interp_named_p (INTERP_MI) 1423 && !current_interp_named_p (INTERP_MI1)) 1424 return; 1425 1426 update_threshold.tv_sec = 0; 1427 update_threshold.tv_usec = 500000; 1428 gettimeofday (&time_now, NULL); 1429 1430 delta.tv_usec = time_now.tv_usec - last_update.tv_usec; 1431 delta.tv_sec = time_now.tv_sec - last_update.tv_sec; 1432 1433 if (delta.tv_usec < 0) 1434 { 1435 delta.tv_sec -= 1; 1436 delta.tv_usec += 1000000; 1437 } 1438 1439 new_section = (previous_sect_name ? 1440 strcmp (previous_sect_name, section_name) : 1); 1441 if (new_section) 1442 { 1443 struct cleanup *cleanup_tuple; 1444 xfree (previous_sect_name); 1445 previous_sect_name = xstrdup (section_name); 1446 1447 if (last_async_command) 1448 fputs_unfiltered (last_async_command, raw_stdout); 1449 fputs_unfiltered ("+download", raw_stdout); 1450 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 1451 ui_out_field_string (uiout, "section", section_name); 1452 ui_out_field_int (uiout, "section-size", total_section); 1453 ui_out_field_int (uiout, "total-size", grand_total); 1454 do_cleanups (cleanup_tuple); 1455 mi_out_put (uiout, raw_stdout); 1456 fputs_unfiltered ("\n", raw_stdout); 1457 gdb_flush (raw_stdout); 1458 } 1459 1460 if (delta.tv_sec >= update_threshold.tv_sec && 1461 delta.tv_usec >= update_threshold.tv_usec) 1462 { 1463 struct cleanup *cleanup_tuple; 1464 last_update.tv_sec = time_now.tv_sec; 1465 last_update.tv_usec = time_now.tv_usec; 1466 if (last_async_command) 1467 fputs_unfiltered (last_async_command, raw_stdout); 1468 fputs_unfiltered ("+download", raw_stdout); 1469 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 1470 ui_out_field_string (uiout, "section", section_name); 1471 ui_out_field_int (uiout, "section-sent", sent_so_far); 1472 ui_out_field_int (uiout, "section-size", total_section); 1473 ui_out_field_int (uiout, "total-sent", total_sent); 1474 ui_out_field_int (uiout, "total-size", grand_total); 1475 do_cleanups (cleanup_tuple); 1476 mi_out_put (uiout, raw_stdout); 1477 fputs_unfiltered ("\n", raw_stdout); 1478 gdb_flush (raw_stdout); 1479 } 1480} 1481 1482void 1483mi_setup_architecture_data (void) 1484{ 1485 old_regs = xmalloc ((NUM_REGS + NUM_PSEUDO_REGS) * MAX_REGISTER_SIZE + 1); 1486 memset (old_regs, 0, (NUM_REGS + NUM_PSEUDO_REGS) * MAX_REGISTER_SIZE + 1); 1487} 1488 1489void 1490_initialize_mi_main (void) 1491{ 1492 DEPRECATED_REGISTER_GDBARCH_SWAP (old_regs); 1493 deprecated_register_gdbarch_swap (NULL, 0, mi_setup_architecture_data); 1494} 1495