1 /* MI Command Set. 2 3 Copyright (C) 2000-2013 Free Software Foundation, Inc. 4 5 Contributed by Cygnus Solutions (a Red Hat company). 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 "arch-utils.h" 24 #include "target.h" 25 #include "inferior.h" 26 #include "gdb_string.h" 27 #include "exceptions.h" 28 #include "top.h" 29 #include "gdbthread.h" 30 #include "mi-cmds.h" 31 #include "mi-parse.h" 32 #include "mi-getopt.h" 33 #include "mi-console.h" 34 #include "ui-out.h" 35 #include "mi-out.h" 36 #include "interps.h" 37 #include "event-loop.h" 38 #include "event-top.h" 39 #include "gdbcore.h" /* For write_memory(). */ 40 #include "value.h" 41 #include "regcache.h" 42 #include "gdb.h" 43 #include "frame.h" 44 #include "mi-main.h" 45 #include "mi-common.h" 46 #include "language.h" 47 #include "valprint.h" 48 #include "inferior.h" 49 #include "osdata.h" 50 #include "splay-tree.h" 51 #include "tracepoint.h" 52 #include "ada-lang.h" 53 #include "linespec.h" 54 55 #include <ctype.h> 56 #include <sys/time.h> 57 58 #if defined HAVE_SYS_RESOURCE_H 59 #include <sys/resource.h> 60 #endif 61 62 #ifdef HAVE_GETRUSAGE 63 struct rusage rusage; 64 #endif 65 66 enum 67 { 68 FROM_TTY = 0 69 }; 70 71 int mi_debug_p; 72 73 struct ui_file *raw_stdout; 74 75 /* This is used to pass the current command timestamp down to 76 continuation routines. */ 77 static struct mi_timestamp *current_command_ts; 78 79 static int do_timings = 0; 80 81 char *current_token; 82 /* Few commands would like to know if options like --thread-group were 83 explicitly specified. This variable keeps the current parsed 84 command including all option, and make it possible. */ 85 static struct mi_parse *current_context; 86 87 int running_result_record_printed = 1; 88 89 /* Flag indicating that the target has proceeded since the last 90 command was issued. */ 91 int mi_proceeded; 92 93 extern void _initialize_mi_main (void); 94 static void mi_cmd_execute (struct mi_parse *parse); 95 96 static void mi_execute_cli_command (const char *cmd, int args_p, 97 const char *args); 98 static void mi_execute_async_cli_command (char *cli_command, 99 char **argv, int argc); 100 static int register_changed_p (int regnum, struct regcache *, 101 struct regcache *); 102 static void get_register (struct frame_info *, int regnum, int format); 103 104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI 105 layer that calls libgdb. Any operation used in the below should be 106 formalized. */ 107 108 static void timestamp (struct mi_timestamp *tv); 109 110 static void print_diff_now (struct mi_timestamp *start); 111 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end); 112 113 void 114 mi_cmd_gdb_exit (char *command, char **argv, int argc) 115 { 116 /* We have to print everything right here because we never return. */ 117 if (current_token) 118 fputs_unfiltered (current_token, raw_stdout); 119 fputs_unfiltered ("^exit\n", raw_stdout); 120 mi_out_put (current_uiout, raw_stdout); 121 gdb_flush (raw_stdout); 122 /* FIXME: The function called is not yet a formal libgdb function. */ 123 quit_force (NULL, FROM_TTY); 124 } 125 126 void 127 mi_cmd_exec_next (char *command, char **argv, int argc) 128 { 129 /* FIXME: Should call a libgdb function, not a cli wrapper. */ 130 if (argc > 0 && strcmp(argv[0], "--reverse") == 0) 131 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1); 132 else 133 mi_execute_async_cli_command ("next", argv, argc); 134 } 135 136 void 137 mi_cmd_exec_next_instruction (char *command, char **argv, int argc) 138 { 139 /* FIXME: Should call a libgdb function, not a cli wrapper. */ 140 if (argc > 0 && strcmp(argv[0], "--reverse") == 0) 141 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1); 142 else 143 mi_execute_async_cli_command ("nexti", argv, argc); 144 } 145 146 void 147 mi_cmd_exec_step (char *command, char **argv, int argc) 148 { 149 /* FIXME: Should call a libgdb function, not a cli wrapper. */ 150 if (argc > 0 && strcmp(argv[0], "--reverse") == 0) 151 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1); 152 else 153 mi_execute_async_cli_command ("step", argv, argc); 154 } 155 156 void 157 mi_cmd_exec_step_instruction (char *command, char **argv, int argc) 158 { 159 /* FIXME: Should call a libgdb function, not a cli wrapper. */ 160 if (argc > 0 && strcmp(argv[0], "--reverse") == 0) 161 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1); 162 else 163 mi_execute_async_cli_command ("stepi", argv, argc); 164 } 165 166 void 167 mi_cmd_exec_finish (char *command, char **argv, int argc) 168 { 169 /* FIXME: Should call a libgdb function, not a cli wrapper. */ 170 if (argc > 0 && strcmp(argv[0], "--reverse") == 0) 171 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1); 172 else 173 mi_execute_async_cli_command ("finish", argv, argc); 174 } 175 176 void 177 mi_cmd_exec_return (char *command, char **argv, int argc) 178 { 179 /* This command doesn't really execute the target, it just pops the 180 specified number of frames. */ 181 if (argc) 182 /* Call return_command with from_tty argument equal to 0 so as to 183 avoid being queried. */ 184 return_command (*argv, 0); 185 else 186 /* Call return_command with from_tty argument equal to 0 so as to 187 avoid being queried. */ 188 return_command (NULL, 0); 189 190 /* Because we have called return_command with from_tty = 0, we need 191 to print the frame here. */ 192 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS); 193 } 194 195 void 196 mi_cmd_exec_jump (char *args, char **argv, int argc) 197 { 198 /* FIXME: Should call a libgdb function, not a cli wrapper. */ 199 mi_execute_async_cli_command ("jump", argv, argc); 200 } 201 202 static void 203 proceed_thread (struct thread_info *thread, int pid) 204 { 205 if (!is_stopped (thread->ptid)) 206 return; 207 208 if (pid != 0 && PIDGET (thread->ptid) != pid) 209 return; 210 211 switch_to_thread (thread->ptid); 212 clear_proceed_status (); 213 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0); 214 } 215 216 static int 217 proceed_thread_callback (struct thread_info *thread, void *arg) 218 { 219 int pid = *(int *)arg; 220 221 proceed_thread (thread, pid); 222 return 0; 223 } 224 225 static void 226 exec_continue (char **argv, int argc) 227 { 228 if (non_stop) 229 { 230 /* In non-stop mode, 'resume' always resumes a single thread. 231 Therefore, to resume all threads of the current inferior, or 232 all threads in all inferiors, we need to iterate over 233 threads. 234 235 See comment on infcmd.c:proceed_thread_callback for rationale. */ 236 if (current_context->all || current_context->thread_group != -1) 237 { 238 int pid = 0; 239 struct cleanup *back_to = make_cleanup_restore_current_thread (); 240 241 if (!current_context->all) 242 { 243 struct inferior *inf 244 = find_inferior_id (current_context->thread_group); 245 246 pid = inf->pid; 247 } 248 iterate_over_threads (proceed_thread_callback, &pid); 249 do_cleanups (back_to); 250 } 251 else 252 { 253 continue_1 (0); 254 } 255 } 256 else 257 { 258 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi); 259 260 if (current_context->all) 261 { 262 sched_multi = 1; 263 continue_1 (0); 264 } 265 else 266 { 267 /* In all-stop mode, -exec-continue traditionally resumed 268 either all threads, or one thread, depending on the 269 'scheduler-locking' variable. Let's continue to do the 270 same. */ 271 continue_1 (1); 272 } 273 do_cleanups (back_to); 274 } 275 } 276 277 static void 278 exec_direction_forward (void *notused) 279 { 280 execution_direction = EXEC_FORWARD; 281 } 282 283 static void 284 exec_reverse_continue (char **argv, int argc) 285 { 286 enum exec_direction_kind dir = execution_direction; 287 struct cleanup *old_chain; 288 289 if (dir == EXEC_REVERSE) 290 error (_("Already in reverse mode.")); 291 292 if (!target_can_execute_reverse) 293 error (_("Target %s does not support this command."), target_shortname); 294 295 old_chain = make_cleanup (exec_direction_forward, NULL); 296 execution_direction = EXEC_REVERSE; 297 exec_continue (argv, argc); 298 do_cleanups (old_chain); 299 } 300 301 void 302 mi_cmd_exec_continue (char *command, char **argv, int argc) 303 { 304 if (argc > 0 && strcmp (argv[0], "--reverse") == 0) 305 exec_reverse_continue (argv + 1, argc - 1); 306 else 307 exec_continue (argv, argc); 308 } 309 310 static int 311 interrupt_thread_callback (struct thread_info *thread, void *arg) 312 { 313 int pid = *(int *)arg; 314 315 if (!is_running (thread->ptid)) 316 return 0; 317 318 if (PIDGET (thread->ptid) != pid) 319 return 0; 320 321 target_stop (thread->ptid); 322 return 0; 323 } 324 325 /* Interrupt the execution of the target. Note how we must play 326 around with the token variables, in order to display the current 327 token in the result of the interrupt command, and the previous 328 execution token when the target finally stops. See comments in 329 mi_cmd_execute. */ 330 331 void 332 mi_cmd_exec_interrupt (char *command, char **argv, int argc) 333 { 334 /* In all-stop mode, everything stops, so we don't need to try 335 anything specific. */ 336 if (!non_stop) 337 { 338 interrupt_target_1 (0); 339 return; 340 } 341 342 if (current_context->all) 343 { 344 /* This will interrupt all threads in all inferiors. */ 345 interrupt_target_1 (1); 346 } 347 else if (current_context->thread_group != -1) 348 { 349 struct inferior *inf = find_inferior_id (current_context->thread_group); 350 351 iterate_over_threads (interrupt_thread_callback, &inf->pid); 352 } 353 else 354 { 355 /* Interrupt just the current thread -- either explicitly 356 specified via --thread or whatever was current before 357 MI command was sent. */ 358 interrupt_target_1 (0); 359 } 360 } 361 362 static int 363 run_one_inferior (struct inferior *inf, void *arg) 364 { 365 if (inf->pid != 0) 366 { 367 if (inf->pid != ptid_get_pid (inferior_ptid)) 368 { 369 struct thread_info *tp; 370 371 tp = any_thread_of_process (inf->pid); 372 if (!tp) 373 error (_("Inferior has no threads.")); 374 375 switch_to_thread (tp->ptid); 376 } 377 } 378 else 379 { 380 set_current_inferior (inf); 381 switch_to_thread (null_ptid); 382 set_current_program_space (inf->pspace); 383 } 384 mi_execute_cli_command ("run", target_can_async_p (), 385 target_can_async_p () ? "&" : NULL); 386 return 0; 387 } 388 389 void 390 mi_cmd_exec_run (char *command, char **argv, int argc) 391 { 392 if (current_context->all) 393 { 394 struct cleanup *back_to = save_current_space_and_thread (); 395 396 iterate_over_inferiors (run_one_inferior, NULL); 397 do_cleanups (back_to); 398 } 399 else 400 { 401 mi_execute_cli_command ("run", target_can_async_p (), 402 target_can_async_p () ? "&" : NULL); 403 } 404 } 405 406 407 static int 408 find_thread_of_process (struct thread_info *ti, void *p) 409 { 410 int pid = *(int *)p; 411 412 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid)) 413 return 1; 414 415 return 0; 416 } 417 418 void 419 mi_cmd_target_detach (char *command, char **argv, int argc) 420 { 421 if (argc != 0 && argc != 1) 422 error (_("Usage: -target-detach [pid | thread-group]")); 423 424 if (argc == 1) 425 { 426 struct thread_info *tp; 427 char *end = argv[0]; 428 int pid; 429 430 /* First see if we are dealing with a thread-group id. */ 431 if (*argv[0] == 'i') 432 { 433 struct inferior *inf; 434 int id = strtoul (argv[0] + 1, &end, 0); 435 436 if (*end != '\0') 437 error (_("Invalid syntax of thread-group id '%s'"), argv[0]); 438 439 inf = find_inferior_id (id); 440 if (!inf) 441 error (_("Non-existent thread-group id '%d'"), id); 442 443 pid = inf->pid; 444 } 445 else 446 { 447 /* We must be dealing with a pid. */ 448 pid = strtol (argv[0], &end, 10); 449 450 if (*end != '\0') 451 error (_("Invalid identifier '%s'"), argv[0]); 452 } 453 454 /* Pick any thread in the desired process. Current 455 target_detach detaches from the parent of inferior_ptid. */ 456 tp = iterate_over_threads (find_thread_of_process, &pid); 457 if (!tp) 458 error (_("Thread group is empty")); 459 460 switch_to_thread (tp->ptid); 461 } 462 463 detach_command (NULL, 0); 464 } 465 466 void 467 mi_cmd_thread_select (char *command, char **argv, int argc) 468 { 469 enum gdb_rc rc; 470 char *mi_error_message; 471 472 if (argc != 1) 473 error (_("-thread-select: USAGE: threadnum.")); 474 475 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message); 476 477 if (rc == GDB_RC_FAIL) 478 { 479 make_cleanup (xfree, mi_error_message); 480 error ("%s", mi_error_message); 481 } 482 } 483 484 void 485 mi_cmd_thread_list_ids (char *command, char **argv, int argc) 486 { 487 enum gdb_rc rc; 488 char *mi_error_message; 489 490 if (argc != 0) 491 error (_("-thread-list-ids: No arguments required.")); 492 493 rc = gdb_list_thread_ids (current_uiout, &mi_error_message); 494 495 if (rc == GDB_RC_FAIL) 496 { 497 make_cleanup (xfree, mi_error_message); 498 error ("%s", mi_error_message); 499 } 500 } 501 502 void 503 mi_cmd_thread_info (char *command, char **argv, int argc) 504 { 505 if (argc != 0 && argc != 1) 506 error (_("Invalid MI command")); 507 508 print_thread_info (current_uiout, argv[0], -1); 509 } 510 511 DEF_VEC_I(int); 512 513 struct collect_cores_data 514 { 515 int pid; 516 517 VEC (int) *cores; 518 }; 519 520 static int 521 collect_cores (struct thread_info *ti, void *xdata) 522 { 523 struct collect_cores_data *data = xdata; 524 525 if (ptid_get_pid (ti->ptid) == data->pid) 526 { 527 int core = target_core_of_thread (ti->ptid); 528 529 if (core != -1) 530 VEC_safe_push (int, data->cores, core); 531 } 532 533 return 0; 534 } 535 536 static int * 537 unique (int *b, int *e) 538 { 539 int *d = b; 540 541 while (++b != e) 542 if (*d != *b) 543 *++d = *b; 544 return ++d; 545 } 546 547 struct print_one_inferior_data 548 { 549 int recurse; 550 VEC (int) *inferiors; 551 }; 552 553 static int 554 print_one_inferior (struct inferior *inferior, void *xdata) 555 { 556 struct print_one_inferior_data *top_data = xdata; 557 struct ui_out *uiout = current_uiout; 558 559 if (VEC_empty (int, top_data->inferiors) 560 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors), 561 VEC_length (int, top_data->inferiors), sizeof (int), 562 compare_positive_ints)) 563 { 564 struct collect_cores_data data; 565 struct cleanup *back_to 566 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 567 568 ui_out_field_fmt (uiout, "id", "i%d", inferior->num); 569 ui_out_field_string (uiout, "type", "process"); 570 if (inferior->pid != 0) 571 ui_out_field_int (uiout, "pid", inferior->pid); 572 573 if (inferior->pspace->pspace_exec_filename != NULL) 574 { 575 ui_out_field_string (uiout, "executable", 576 inferior->pspace->pspace_exec_filename); 577 } 578 579 data.cores = 0; 580 if (inferior->pid != 0) 581 { 582 data.pid = inferior->pid; 583 iterate_over_threads (collect_cores, &data); 584 } 585 586 if (!VEC_empty (int, data.cores)) 587 { 588 int *b, *e; 589 struct cleanup *back_to_2 = 590 make_cleanup_ui_out_list_begin_end (uiout, "cores"); 591 592 qsort (VEC_address (int, data.cores), 593 VEC_length (int, data.cores), sizeof (int), 594 compare_positive_ints); 595 596 b = VEC_address (int, data.cores); 597 e = b + VEC_length (int, data.cores); 598 e = unique (b, e); 599 600 for (; b != e; ++b) 601 ui_out_field_int (uiout, NULL, *b); 602 603 do_cleanups (back_to_2); 604 } 605 606 if (top_data->recurse) 607 print_thread_info (uiout, NULL, inferior->pid); 608 609 do_cleanups (back_to); 610 } 611 612 return 0; 613 } 614 615 /* Output a field named 'cores' with a list as the value. The 616 elements of the list are obtained by splitting 'cores' on 617 comma. */ 618 619 static void 620 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores) 621 { 622 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout, 623 field_name); 624 char *cores = xstrdup (xcores); 625 char *p = cores; 626 627 make_cleanup (xfree, cores); 628 629 for (p = strtok (p, ","); p; p = strtok (NULL, ",")) 630 ui_out_field_string (uiout, NULL, p); 631 632 do_cleanups (back_to); 633 } 634 635 static void 636 free_vector_of_ints (void *xvector) 637 { 638 VEC (int) **vector = xvector; 639 640 VEC_free (int, *vector); 641 } 642 643 static void 644 do_nothing (splay_tree_key k) 645 { 646 } 647 648 static void 649 free_vector_of_osdata_items (splay_tree_value xvalue) 650 { 651 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue; 652 653 /* We don't free the items itself, it will be done separately. */ 654 VEC_free (osdata_item_s, value); 655 } 656 657 static int 658 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb) 659 { 660 int a = xa; 661 int b = xb; 662 663 return a - b; 664 } 665 666 static void 667 free_splay_tree (void *xt) 668 { 669 splay_tree t = xt; 670 splay_tree_delete (t); 671 } 672 673 static void 674 list_available_thread_groups (VEC (int) *ids, int recurse) 675 { 676 struct osdata *data; 677 struct osdata_item *item; 678 int ix_items; 679 struct ui_out *uiout = current_uiout; 680 681 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)* 682 The vector contains information about all threads for the given pid. 683 This is assigned an initial value to avoid "may be used uninitialized" 684 warning from gcc. */ 685 splay_tree tree = NULL; 686 687 /* get_osdata will throw if it cannot return data. */ 688 data = get_osdata ("processes"); 689 make_cleanup_osdata_free (data); 690 691 if (recurse) 692 { 693 struct osdata *threads = get_osdata ("threads"); 694 695 make_cleanup_osdata_free (threads); 696 tree = splay_tree_new (splay_tree_int_comparator, 697 do_nothing, 698 free_vector_of_osdata_items); 699 make_cleanup (free_splay_tree, tree); 700 701 for (ix_items = 0; 702 VEC_iterate (osdata_item_s, threads->items, 703 ix_items, item); 704 ix_items++) 705 { 706 const char *pid = get_osdata_column (item, "pid"); 707 int pid_i = strtoul (pid, NULL, 0); 708 VEC (osdata_item_s) *vec = 0; 709 710 splay_tree_node n = splay_tree_lookup (tree, pid_i); 711 if (!n) 712 { 713 VEC_safe_push (osdata_item_s, vec, item); 714 splay_tree_insert (tree, pid_i, (splay_tree_value)vec); 715 } 716 else 717 { 718 vec = (VEC (osdata_item_s) *) n->value; 719 VEC_safe_push (osdata_item_s, vec, item); 720 n->value = (splay_tree_value) vec; 721 } 722 } 723 } 724 725 make_cleanup_ui_out_list_begin_end (uiout, "groups"); 726 727 for (ix_items = 0; 728 VEC_iterate (osdata_item_s, data->items, 729 ix_items, item); 730 ix_items++) 731 { 732 struct cleanup *back_to; 733 734 const char *pid = get_osdata_column (item, "pid"); 735 const char *cmd = get_osdata_column (item, "command"); 736 const char *user = get_osdata_column (item, "user"); 737 const char *cores = get_osdata_column (item, "cores"); 738 739 int pid_i = strtoul (pid, NULL, 0); 740 741 /* At present, the target will return all available processes 742 and if information about specific ones was required, we filter 743 undesired processes here. */ 744 if (ids && bsearch (&pid_i, VEC_address (int, ids), 745 VEC_length (int, ids), 746 sizeof (int), compare_positive_ints) == NULL) 747 continue; 748 749 750 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 751 752 ui_out_field_fmt (uiout, "id", "%s", pid); 753 ui_out_field_string (uiout, "type", "process"); 754 if (cmd) 755 ui_out_field_string (uiout, "description", cmd); 756 if (user) 757 ui_out_field_string (uiout, "user", user); 758 if (cores) 759 output_cores (uiout, "cores", cores); 760 761 if (recurse) 762 { 763 splay_tree_node n = splay_tree_lookup (tree, pid_i); 764 if (n) 765 { 766 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value; 767 struct osdata_item *child; 768 int ix_child; 769 770 make_cleanup_ui_out_list_begin_end (uiout, "threads"); 771 772 for (ix_child = 0; 773 VEC_iterate (osdata_item_s, children, ix_child, child); 774 ++ix_child) 775 { 776 struct cleanup *back_to_2 = 777 make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 778 const char *tid = get_osdata_column (child, "tid"); 779 const char *tcore = get_osdata_column (child, "core"); 780 781 ui_out_field_string (uiout, "id", tid); 782 if (tcore) 783 ui_out_field_string (uiout, "core", tcore); 784 785 do_cleanups (back_to_2); 786 } 787 } 788 } 789 790 do_cleanups (back_to); 791 } 792 } 793 794 void 795 mi_cmd_list_thread_groups (char *command, char **argv, int argc) 796 { 797 struct ui_out *uiout = current_uiout; 798 struct cleanup *back_to; 799 int available = 0; 800 int recurse = 0; 801 VEC (int) *ids = 0; 802 803 enum opt 804 { 805 AVAILABLE_OPT, RECURSE_OPT 806 }; 807 static const struct mi_opt opts[] = 808 { 809 {"-available", AVAILABLE_OPT, 0}, 810 {"-recurse", RECURSE_OPT, 1}, 811 { 0, 0, 0 } 812 }; 813 814 int oind = 0; 815 char *oarg; 816 817 while (1) 818 { 819 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts, 820 &oind, &oarg); 821 822 if (opt < 0) 823 break; 824 switch ((enum opt) opt) 825 { 826 case AVAILABLE_OPT: 827 available = 1; 828 break; 829 case RECURSE_OPT: 830 if (strcmp (oarg, "0") == 0) 831 ; 832 else if (strcmp (oarg, "1") == 0) 833 recurse = 1; 834 else 835 error (_("only '0' and '1' are valid values " 836 "for the '--recurse' option")); 837 break; 838 } 839 } 840 841 for (; oind < argc; ++oind) 842 { 843 char *end; 844 int inf; 845 846 if (*(argv[oind]) != 'i') 847 error (_("invalid syntax of group id '%s'"), argv[oind]); 848 849 inf = strtoul (argv[oind] + 1, &end, 0); 850 851 if (*end != '\0') 852 error (_("invalid syntax of group id '%s'"), argv[oind]); 853 VEC_safe_push (int, ids, inf); 854 } 855 if (VEC_length (int, ids) > 1) 856 qsort (VEC_address (int, ids), 857 VEC_length (int, ids), 858 sizeof (int), compare_positive_ints); 859 860 back_to = make_cleanup (free_vector_of_ints, &ids); 861 862 if (available) 863 { 864 list_available_thread_groups (ids, recurse); 865 } 866 else if (VEC_length (int, ids) == 1) 867 { 868 /* Local thread groups, single id. */ 869 int id = *VEC_address (int, ids); 870 struct inferior *inf = find_inferior_id (id); 871 872 if (!inf) 873 error (_("Non-existent thread group id '%d'"), id); 874 875 print_thread_info (uiout, NULL, inf->pid); 876 } 877 else 878 { 879 struct print_one_inferior_data data; 880 881 data.recurse = recurse; 882 data.inferiors = ids; 883 884 /* Local thread groups. Either no explicit ids -- and we 885 print everything, or several explicit ids. In both cases, 886 we print more than one group, and have to use 'groups' 887 as the top-level element. */ 888 make_cleanup_ui_out_list_begin_end (uiout, "groups"); 889 update_thread_list (); 890 iterate_over_inferiors (print_one_inferior, &data); 891 } 892 893 do_cleanups (back_to); 894 } 895 896 void 897 mi_cmd_data_list_register_names (char *command, char **argv, int argc) 898 { 899 struct gdbarch *gdbarch; 900 struct ui_out *uiout = current_uiout; 901 int regnum, numregs; 902 int i; 903 struct cleanup *cleanup; 904 905 /* Note that the test for a valid register must include checking the 906 gdbarch_register_name because gdbarch_num_regs may be allocated 907 for the union of the register sets within a family of related 908 processors. In this case, some entries of gdbarch_register_name 909 will change depending upon the particular processor being 910 debugged. */ 911 912 gdbarch = get_current_arch (); 913 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); 914 915 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names"); 916 917 if (argc == 0) /* No args, just do all the regs. */ 918 { 919 for (regnum = 0; 920 regnum < numregs; 921 regnum++) 922 { 923 if (gdbarch_register_name (gdbarch, regnum) == NULL 924 || *(gdbarch_register_name (gdbarch, regnum)) == '\0') 925 ui_out_field_string (uiout, NULL, ""); 926 else 927 ui_out_field_string (uiout, NULL, 928 gdbarch_register_name (gdbarch, regnum)); 929 } 930 } 931 932 /* Else, list of register #s, just do listed regs. */ 933 for (i = 0; i < argc; i++) 934 { 935 regnum = atoi (argv[i]); 936 if (regnum < 0 || regnum >= numregs) 937 error (_("bad register number")); 938 939 if (gdbarch_register_name (gdbarch, regnum) == NULL 940 || *(gdbarch_register_name (gdbarch, regnum)) == '\0') 941 ui_out_field_string (uiout, NULL, ""); 942 else 943 ui_out_field_string (uiout, NULL, 944 gdbarch_register_name (gdbarch, regnum)); 945 } 946 do_cleanups (cleanup); 947 } 948 949 void 950 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc) 951 { 952 static struct regcache *this_regs = NULL; 953 struct ui_out *uiout = current_uiout; 954 struct regcache *prev_regs; 955 struct gdbarch *gdbarch; 956 int regnum, numregs, changed; 957 int i; 958 struct cleanup *cleanup; 959 960 /* The last time we visited this function, the current frame's 961 register contents were saved in THIS_REGS. Move THIS_REGS over 962 to PREV_REGS, and refresh THIS_REGS with the now-current register 963 contents. */ 964 965 prev_regs = this_regs; 966 this_regs = frame_save_as_regcache (get_selected_frame (NULL)); 967 cleanup = make_cleanup_regcache_xfree (prev_regs); 968 969 /* Note that the test for a valid register must include checking the 970 gdbarch_register_name because gdbarch_num_regs may be allocated 971 for the union of the register sets within a family of related 972 processors. In this case, some entries of gdbarch_register_name 973 will change depending upon the particular processor being 974 debugged. */ 975 976 gdbarch = get_regcache_arch (this_regs); 977 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); 978 979 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers"); 980 981 if (argc == 0) 982 { 983 /* No args, just do all the regs. */ 984 for (regnum = 0; 985 regnum < numregs; 986 regnum++) 987 { 988 if (gdbarch_register_name (gdbarch, regnum) == NULL 989 || *(gdbarch_register_name (gdbarch, regnum)) == '\0') 990 continue; 991 changed = register_changed_p (regnum, prev_regs, this_regs); 992 if (changed < 0) 993 error (_("-data-list-changed-registers: " 994 "Unable to read register contents.")); 995 else if (changed) 996 ui_out_field_int (uiout, NULL, regnum); 997 } 998 } 999 1000 /* Else, list of register #s, just do listed regs. */ 1001 for (i = 0; i < argc; i++) 1002 { 1003 regnum = atoi (argv[i]); 1004 1005 if (regnum >= 0 1006 && regnum < numregs 1007 && gdbarch_register_name (gdbarch, regnum) != NULL 1008 && *gdbarch_register_name (gdbarch, regnum) != '\000') 1009 { 1010 changed = register_changed_p (regnum, prev_regs, this_regs); 1011 if (changed < 0) 1012 error (_("-data-list-changed-registers: " 1013 "Unable to read register contents.")); 1014 else if (changed) 1015 ui_out_field_int (uiout, NULL, regnum); 1016 } 1017 else 1018 error (_("bad register number")); 1019 } 1020 do_cleanups (cleanup); 1021 } 1022 1023 static int 1024 register_changed_p (int regnum, struct regcache *prev_regs, 1025 struct regcache *this_regs) 1026 { 1027 struct gdbarch *gdbarch = get_regcache_arch (this_regs); 1028 gdb_byte prev_buffer[MAX_REGISTER_SIZE]; 1029 gdb_byte this_buffer[MAX_REGISTER_SIZE]; 1030 enum register_status prev_status; 1031 enum register_status this_status; 1032 1033 /* First time through or after gdbarch change consider all registers 1034 as changed. */ 1035 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch) 1036 return 1; 1037 1038 /* Get register contents and compare. */ 1039 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer); 1040 this_status = regcache_cooked_read (this_regs, regnum, this_buffer); 1041 1042 if (this_status != prev_status) 1043 return 1; 1044 else if (this_status == REG_VALID) 1045 return memcmp (prev_buffer, this_buffer, 1046 register_size (gdbarch, regnum)) != 0; 1047 else 1048 return 0; 1049 } 1050 1051 /* Return a list of register number and value pairs. The valid 1052 arguments expected are: a letter indicating the format in which to 1053 display the registers contents. This can be one of: x 1054 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r 1055 (raw). After the format argument there can be a sequence of 1056 numbers, indicating which registers to fetch the content of. If 1057 the format is the only argument, a list of all the registers with 1058 their values is returned. */ 1059 1060 void 1061 mi_cmd_data_list_register_values (char *command, char **argv, int argc) 1062 { 1063 struct ui_out *uiout = current_uiout; 1064 struct frame_info *frame; 1065 struct gdbarch *gdbarch; 1066 int regnum, numregs, format; 1067 int i; 1068 struct cleanup *list_cleanup, *tuple_cleanup; 1069 1070 /* Note that the test for a valid register must include checking the 1071 gdbarch_register_name because gdbarch_num_regs may be allocated 1072 for the union of the register sets within a family of related 1073 processors. In this case, some entries of gdbarch_register_name 1074 will change depending upon the particular processor being 1075 debugged. */ 1076 1077 if (argc == 0) 1078 error (_("-data-list-register-values: Usage: " 1079 "-data-list-register-values <format> [<regnum1>...<regnumN>]")); 1080 1081 format = (int) argv[0][0]; 1082 1083 frame = get_selected_frame (NULL); 1084 gdbarch = get_frame_arch (frame); 1085 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); 1086 1087 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values"); 1088 1089 if (argc == 1) 1090 { 1091 /* No args, beside the format: do all the regs. */ 1092 for (regnum = 0; 1093 regnum < numregs; 1094 regnum++) 1095 { 1096 if (gdbarch_register_name (gdbarch, regnum) == NULL 1097 || *(gdbarch_register_name (gdbarch, regnum)) == '\0') 1098 continue; 1099 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 1100 ui_out_field_int (uiout, "number", regnum); 1101 get_register (frame, regnum, format); 1102 do_cleanups (tuple_cleanup); 1103 } 1104 } 1105 1106 /* Else, list of register #s, just do listed regs. */ 1107 for (i = 1; i < argc; i++) 1108 { 1109 regnum = atoi (argv[i]); 1110 1111 if (regnum >= 0 1112 && regnum < numregs 1113 && gdbarch_register_name (gdbarch, regnum) != NULL 1114 && *gdbarch_register_name (gdbarch, regnum) != '\000') 1115 { 1116 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 1117 ui_out_field_int (uiout, "number", regnum); 1118 get_register (frame, regnum, format); 1119 do_cleanups (tuple_cleanup); 1120 } 1121 else 1122 error (_("bad register number")); 1123 } 1124 do_cleanups (list_cleanup); 1125 } 1126 1127 /* Output one register's contents in the desired format. */ 1128 1129 static void 1130 get_register (struct frame_info *frame, int regnum, int format) 1131 { 1132 struct gdbarch *gdbarch = get_frame_arch (frame); 1133 struct ui_out *uiout = current_uiout; 1134 struct value *val; 1135 1136 if (format == 'N') 1137 format = 0; 1138 1139 val = get_frame_register_value (frame, regnum); 1140 1141 if (value_optimized_out (val)) 1142 error (_("Optimized out")); 1143 1144 if (format == 'r') 1145 { 1146 int j; 1147 char *ptr, buf[1024]; 1148 const gdb_byte *valaddr = value_contents_for_printing (val); 1149 1150 strcpy (buf, "0x"); 1151 ptr = buf + 2; 1152 for (j = 0; j < register_size (gdbarch, regnum); j++) 1153 { 1154 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? 1155 j : register_size (gdbarch, regnum) - 1 - j; 1156 1157 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]); 1158 ptr += 2; 1159 } 1160 ui_out_field_string (uiout, "value", buf); 1161 } 1162 else 1163 { 1164 struct value_print_options opts; 1165 struct ui_file *stb; 1166 struct cleanup *old_chain; 1167 1168 stb = mem_fileopen (); 1169 old_chain = make_cleanup_ui_file_delete (stb); 1170 1171 get_formatted_print_options (&opts, format); 1172 opts.deref_ref = 1; 1173 val_print (value_type (val), 1174 value_contents_for_printing (val), 1175 value_embedded_offset (val), 0, 1176 stb, 0, val, &opts, current_language); 1177 ui_out_field_stream (uiout, "value", stb); 1178 do_cleanups (old_chain); 1179 } 1180 } 1181 1182 /* Write given values into registers. The registers and values are 1183 given as pairs. The corresponding MI command is 1184 -data-write-register-values <format> 1185 [<regnum1> <value1>...<regnumN> <valueN>] */ 1186 void 1187 mi_cmd_data_write_register_values (char *command, char **argv, int argc) 1188 { 1189 struct regcache *regcache; 1190 struct gdbarch *gdbarch; 1191 int numregs, i; 1192 1193 /* Note that the test for a valid register must include checking the 1194 gdbarch_register_name because gdbarch_num_regs may be allocated 1195 for the union of the register sets within a family of related 1196 processors. In this case, some entries of gdbarch_register_name 1197 will change depending upon the particular processor being 1198 debugged. */ 1199 1200 regcache = get_current_regcache (); 1201 gdbarch = get_regcache_arch (regcache); 1202 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); 1203 1204 if (argc == 0) 1205 error (_("-data-write-register-values: Usage: -data-write-register-" 1206 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]")); 1207 1208 if (!target_has_registers) 1209 error (_("-data-write-register-values: No registers.")); 1210 1211 if (!(argc - 1)) 1212 error (_("-data-write-register-values: No regs and values specified.")); 1213 1214 if ((argc - 1) % 2) 1215 error (_("-data-write-register-values: " 1216 "Regs and vals are not in pairs.")); 1217 1218 for (i = 1; i < argc; i = i + 2) 1219 { 1220 int regnum = atoi (argv[i]); 1221 1222 if (regnum >= 0 && regnum < numregs 1223 && gdbarch_register_name (gdbarch, regnum) 1224 && *gdbarch_register_name (gdbarch, regnum)) 1225 { 1226 LONGEST value; 1227 1228 /* Get the value as a number. */ 1229 value = parse_and_eval_address (argv[i + 1]); 1230 1231 /* Write it down. */ 1232 regcache_cooked_write_signed (regcache, regnum, value); 1233 } 1234 else 1235 error (_("bad register number")); 1236 } 1237 } 1238 1239 /* Evaluate the value of the argument. The argument is an 1240 expression. If the expression contains spaces it needs to be 1241 included in double quotes. */ 1242 1243 void 1244 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc) 1245 { 1246 struct expression *expr; 1247 struct cleanup *old_chain; 1248 struct value *val; 1249 struct ui_file *stb; 1250 struct value_print_options opts; 1251 struct ui_out *uiout = current_uiout; 1252 1253 stb = mem_fileopen (); 1254 old_chain = make_cleanup_ui_file_delete (stb); 1255 1256 if (argc != 1) 1257 error (_("-data-evaluate-expression: " 1258 "Usage: -data-evaluate-expression expression")); 1259 1260 expr = parse_expression (argv[0]); 1261 1262 make_cleanup (free_current_contents, &expr); 1263 1264 val = evaluate_expression (expr); 1265 1266 /* Print the result of the expression evaluation. */ 1267 get_user_print_options (&opts); 1268 opts.deref_ref = 0; 1269 common_val_print (val, stb, 0, &opts, current_language); 1270 1271 ui_out_field_stream (uiout, "value", stb); 1272 1273 do_cleanups (old_chain); 1274 } 1275 1276 /* This is the -data-read-memory command. 1277 1278 ADDR: start address of data to be dumped. 1279 WORD-FORMAT: a char indicating format for the ``word''. See 1280 the ``x'' command. 1281 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes. 1282 NR_ROW: Number of rows. 1283 NR_COL: The number of colums (words per row). 1284 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use 1285 ASCHAR for unprintable characters. 1286 1287 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and 1288 displayes them. Returns: 1289 1290 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...} 1291 1292 Returns: 1293 The number of bytes read is SIZE*ROW*COL. */ 1294 1295 void 1296 mi_cmd_data_read_memory (char *command, char **argv, int argc) 1297 { 1298 struct gdbarch *gdbarch = get_current_arch (); 1299 struct ui_out *uiout = current_uiout; 1300 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL); 1301 CORE_ADDR addr; 1302 long total_bytes, nr_cols, nr_rows; 1303 char word_format; 1304 struct type *word_type; 1305 long word_size; 1306 char word_asize; 1307 char aschar; 1308 gdb_byte *mbuf; 1309 int nr_bytes; 1310 long offset = 0; 1311 int oind = 0; 1312 char *oarg; 1313 enum opt 1314 { 1315 OFFSET_OPT 1316 }; 1317 static const struct mi_opt opts[] = 1318 { 1319 {"o", OFFSET_OPT, 1}, 1320 { 0, 0, 0 } 1321 }; 1322 1323 while (1) 1324 { 1325 int opt = mi_getopt ("-data-read-memory", argc, argv, opts, 1326 &oind, &oarg); 1327 1328 if (opt < 0) 1329 break; 1330 switch ((enum opt) opt) 1331 { 1332 case OFFSET_OPT: 1333 offset = atol (oarg); 1334 break; 1335 } 1336 } 1337 argv += oind; 1338 argc -= oind; 1339 1340 if (argc < 5 || argc > 6) 1341 error (_("-data-read-memory: Usage: " 1342 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].")); 1343 1344 /* Extract all the arguments. */ 1345 1346 /* Start address of the memory dump. */ 1347 addr = parse_and_eval_address (argv[0]) + offset; 1348 /* The format character to use when displaying a memory word. See 1349 the ``x'' command. */ 1350 word_format = argv[1][0]; 1351 /* The size of the memory word. */ 1352 word_size = atol (argv[2]); 1353 switch (word_size) 1354 { 1355 case 1: 1356 word_type = builtin_type (gdbarch)->builtin_int8; 1357 word_asize = 'b'; 1358 break; 1359 case 2: 1360 word_type = builtin_type (gdbarch)->builtin_int16; 1361 word_asize = 'h'; 1362 break; 1363 case 4: 1364 word_type = builtin_type (gdbarch)->builtin_int32; 1365 word_asize = 'w'; 1366 break; 1367 case 8: 1368 word_type = builtin_type (gdbarch)->builtin_int64; 1369 word_asize = 'g'; 1370 break; 1371 default: 1372 word_type = builtin_type (gdbarch)->builtin_int8; 1373 word_asize = 'b'; 1374 } 1375 /* The number of rows. */ 1376 nr_rows = atol (argv[3]); 1377 if (nr_rows <= 0) 1378 error (_("-data-read-memory: invalid number of rows.")); 1379 1380 /* Number of bytes per row. */ 1381 nr_cols = atol (argv[4]); 1382 if (nr_cols <= 0) 1383 error (_("-data-read-memory: invalid number of columns.")); 1384 1385 /* The un-printable character when printing ascii. */ 1386 if (argc == 6) 1387 aschar = *argv[5]; 1388 else 1389 aschar = 0; 1390 1391 /* Create a buffer and read it in. */ 1392 total_bytes = word_size * nr_rows * nr_cols; 1393 mbuf = xcalloc (total_bytes, 1); 1394 make_cleanup (xfree, mbuf); 1395 1396 /* Dispatch memory reads to the topmost target, not the flattened 1397 current_target. */ 1398 nr_bytes = target_read (current_target.beneath, 1399 TARGET_OBJECT_MEMORY, NULL, mbuf, 1400 addr, total_bytes); 1401 if (nr_bytes <= 0) 1402 error (_("Unable to read memory.")); 1403 1404 /* Output the header information. */ 1405 ui_out_field_core_addr (uiout, "addr", gdbarch, addr); 1406 ui_out_field_int (uiout, "nr-bytes", nr_bytes); 1407 ui_out_field_int (uiout, "total-bytes", total_bytes); 1408 ui_out_field_core_addr (uiout, "next-row", 1409 gdbarch, addr + word_size * nr_cols); 1410 ui_out_field_core_addr (uiout, "prev-row", 1411 gdbarch, addr - word_size * nr_cols); 1412 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes); 1413 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes); 1414 1415 /* Build the result as a two dimentional table. */ 1416 { 1417 struct ui_file *stream; 1418 struct cleanup *cleanup_stream; 1419 int row; 1420 int row_byte; 1421 1422 stream = mem_fileopen (); 1423 cleanup_stream = make_cleanup_ui_file_delete (stream); 1424 1425 make_cleanup_ui_out_list_begin_end (uiout, "memory"); 1426 for (row = 0, row_byte = 0; 1427 row < nr_rows; 1428 row++, row_byte += nr_cols * word_size) 1429 { 1430 int col; 1431 int col_byte; 1432 struct cleanup *cleanup_tuple; 1433 struct cleanup *cleanup_list_data; 1434 struct value_print_options opts; 1435 1436 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 1437 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte); 1438 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + 1439 row_byte); */ 1440 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data"); 1441 get_formatted_print_options (&opts, word_format); 1442 for (col = 0, col_byte = row_byte; 1443 col < nr_cols; 1444 col++, col_byte += word_size) 1445 { 1446 if (col_byte + word_size > nr_bytes) 1447 { 1448 ui_out_field_string (uiout, NULL, "N/A"); 1449 } 1450 else 1451 { 1452 ui_file_rewind (stream); 1453 print_scalar_formatted (mbuf + col_byte, word_type, &opts, 1454 word_asize, stream); 1455 ui_out_field_stream (uiout, NULL, stream); 1456 } 1457 } 1458 do_cleanups (cleanup_list_data); 1459 if (aschar) 1460 { 1461 int byte; 1462 1463 ui_file_rewind (stream); 1464 for (byte = row_byte; 1465 byte < row_byte + word_size * nr_cols; byte++) 1466 { 1467 if (byte >= nr_bytes) 1468 fputc_unfiltered ('X', stream); 1469 else if (mbuf[byte] < 32 || mbuf[byte] > 126) 1470 fputc_unfiltered (aschar, stream); 1471 else 1472 fputc_unfiltered (mbuf[byte], stream); 1473 } 1474 ui_out_field_stream (uiout, "ascii", stream); 1475 } 1476 do_cleanups (cleanup_tuple); 1477 } 1478 do_cleanups (cleanup_stream); 1479 } 1480 do_cleanups (cleanups); 1481 } 1482 1483 void 1484 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) 1485 { 1486 struct gdbarch *gdbarch = get_current_arch (); 1487 struct ui_out *uiout = current_uiout; 1488 struct cleanup *cleanups; 1489 CORE_ADDR addr; 1490 LONGEST length; 1491 memory_read_result_s *read_result; 1492 int ix; 1493 VEC(memory_read_result_s) *result; 1494 long offset = 0; 1495 int oind = 0; 1496 char *oarg; 1497 enum opt 1498 { 1499 OFFSET_OPT 1500 }; 1501 static const struct mi_opt opts[] = 1502 { 1503 {"o", OFFSET_OPT, 1}, 1504 { 0, 0, 0 } 1505 }; 1506 1507 while (1) 1508 { 1509 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts, 1510 &oind, &oarg); 1511 if (opt < 0) 1512 break; 1513 switch ((enum opt) opt) 1514 { 1515 case OFFSET_OPT: 1516 offset = atol (oarg); 1517 break; 1518 } 1519 } 1520 argv += oind; 1521 argc -= oind; 1522 1523 if (argc != 2) 1524 error (_("Usage: [ -o OFFSET ] ADDR LENGTH.")); 1525 1526 addr = parse_and_eval_address (argv[0]) + offset; 1527 length = atol (argv[1]); 1528 1529 result = read_memory_robust (current_target.beneath, addr, length); 1530 1531 cleanups = make_cleanup (free_memory_read_result_vector, result); 1532 1533 if (VEC_length (memory_read_result_s, result) == 0) 1534 error (_("Unable to read memory.")); 1535 1536 make_cleanup_ui_out_list_begin_end (uiout, "memory"); 1537 for (ix = 0; 1538 VEC_iterate (memory_read_result_s, result, ix, read_result); 1539 ++ix) 1540 { 1541 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 1542 char *data, *p; 1543 int i; 1544 1545 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin); 1546 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin 1547 - addr); 1548 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end); 1549 1550 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1); 1551 1552 for (i = 0, p = data; 1553 i < (read_result->end - read_result->begin); 1554 ++i, p += 2) 1555 { 1556 sprintf (p, "%02x", read_result->data[i]); 1557 } 1558 ui_out_field_string (uiout, "contents", data); 1559 xfree (data); 1560 do_cleanups (t); 1561 } 1562 do_cleanups (cleanups); 1563 } 1564 1565 /* Implementation of the -data-write_memory command. 1566 1567 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The 1568 offset from the beginning of the memory grid row where the cell to 1569 be written is. 1570 ADDR: start address of the row in the memory grid where the memory 1571 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of 1572 the location to write to. 1573 FORMAT: a char indicating format for the ``word''. See 1574 the ``x'' command. 1575 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes 1576 VALUE: value to be written into the memory address. 1577 1578 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE). 1579 1580 Prints nothing. */ 1581 1582 void 1583 mi_cmd_data_write_memory (char *command, char **argv, int argc) 1584 { 1585 struct gdbarch *gdbarch = get_current_arch (); 1586 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1587 CORE_ADDR addr; 1588 long word_size; 1589 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big 1590 enough when using a compiler other than GCC. */ 1591 LONGEST value; 1592 void *buffer; 1593 struct cleanup *old_chain; 1594 long offset = 0; 1595 int oind = 0; 1596 char *oarg; 1597 enum opt 1598 { 1599 OFFSET_OPT 1600 }; 1601 static const struct mi_opt opts[] = 1602 { 1603 {"o", OFFSET_OPT, 1}, 1604 { 0, 0, 0 } 1605 }; 1606 1607 while (1) 1608 { 1609 int opt = mi_getopt ("-data-write-memory", argc, argv, opts, 1610 &oind, &oarg); 1611 1612 if (opt < 0) 1613 break; 1614 switch ((enum opt) opt) 1615 { 1616 case OFFSET_OPT: 1617 offset = atol (oarg); 1618 break; 1619 } 1620 } 1621 argv += oind; 1622 argc -= oind; 1623 1624 if (argc != 4) 1625 error (_("-data-write-memory: Usage: " 1626 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.")); 1627 1628 /* Extract all the arguments. */ 1629 /* Start address of the memory dump. */ 1630 addr = parse_and_eval_address (argv[0]); 1631 /* The size of the memory word. */ 1632 word_size = atol (argv[2]); 1633 1634 /* Calculate the real address of the write destination. */ 1635 addr += (offset * word_size); 1636 1637 /* Get the value as a number. */ 1638 value = parse_and_eval_address (argv[3]); 1639 /* Get the value into an array. */ 1640 buffer = xmalloc (word_size); 1641 old_chain = make_cleanup (xfree, buffer); 1642 store_signed_integer (buffer, word_size, byte_order, value); 1643 /* Write it down to memory. */ 1644 write_memory_with_notification (addr, buffer, word_size); 1645 /* Free the buffer. */ 1646 do_cleanups (old_chain); 1647 } 1648 1649 /* Implementation of the -data-write-memory-bytes command. 1650 1651 ADDR: start address 1652 DATA: string of bytes to write at that address 1653 COUNT: number of bytes to be filled (decimal integer). */ 1654 1655 void 1656 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc) 1657 { 1658 CORE_ADDR addr; 1659 char *cdata; 1660 gdb_byte *data; 1661 gdb_byte *databuf; 1662 size_t len, i, steps, remainder; 1663 long int count, j; 1664 struct cleanup *back_to; 1665 1666 if (argc != 2 && argc != 3) 1667 error (_("Usage: ADDR DATA [COUNT].")); 1668 1669 addr = parse_and_eval_address (argv[0]); 1670 cdata = argv[1]; 1671 if (strlen (cdata) % 2) 1672 error (_("Hex-encoded '%s' must have an even number of characters."), 1673 cdata); 1674 1675 len = strlen (cdata)/2; 1676 if (argc == 3) 1677 count = strtoul (argv[2], NULL, 10); 1678 else 1679 count = len; 1680 1681 databuf = xmalloc (len * sizeof (gdb_byte)); 1682 back_to = make_cleanup (xfree, databuf); 1683 1684 for (i = 0; i < len; ++i) 1685 { 1686 int x; 1687 if (sscanf (cdata + i * 2, "%02x", &x) != 1) 1688 error (_("Invalid argument")); 1689 databuf[i] = (gdb_byte) x; 1690 } 1691 1692 if (len < count) 1693 { 1694 /* Pattern is made of less bytes than count: 1695 repeat pattern to fill memory. */ 1696 data = xmalloc (count); 1697 make_cleanup (xfree, data); 1698 1699 steps = count / len; 1700 remainder = count % len; 1701 for (j = 0; j < steps; j++) 1702 memcpy (data + j * len, databuf, len); 1703 1704 if (remainder > 0) 1705 memcpy (data + steps * len, databuf, remainder); 1706 } 1707 else 1708 { 1709 /* Pattern is longer than or equal to count: 1710 just copy len bytes. */ 1711 data = databuf; 1712 } 1713 1714 write_memory_with_notification (addr, data, count); 1715 1716 do_cleanups (back_to); 1717 } 1718 1719 void 1720 mi_cmd_enable_timings (char *command, char **argv, int argc) 1721 { 1722 if (argc == 0) 1723 do_timings = 1; 1724 else if (argc == 1) 1725 { 1726 if (strcmp (argv[0], "yes") == 0) 1727 do_timings = 1; 1728 else if (strcmp (argv[0], "no") == 0) 1729 do_timings = 0; 1730 else 1731 goto usage_error; 1732 } 1733 else 1734 goto usage_error; 1735 1736 return; 1737 1738 usage_error: 1739 error (_("-enable-timings: Usage: %s {yes|no}"), command); 1740 } 1741 1742 void 1743 mi_cmd_list_features (char *command, char **argv, int argc) 1744 { 1745 if (argc == 0) 1746 { 1747 struct cleanup *cleanup = NULL; 1748 struct ui_out *uiout = current_uiout; 1749 1750 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features"); 1751 ui_out_field_string (uiout, NULL, "frozen-varobjs"); 1752 ui_out_field_string (uiout, NULL, "pending-breakpoints"); 1753 ui_out_field_string (uiout, NULL, "thread-info"); 1754 ui_out_field_string (uiout, NULL, "data-read-memory-bytes"); 1755 ui_out_field_string (uiout, NULL, "breakpoint-notifications"); 1756 ui_out_field_string (uiout, NULL, "ada-task-info"); 1757 1758 #if HAVE_PYTHON 1759 ui_out_field_string (uiout, NULL, "python"); 1760 #endif 1761 1762 do_cleanups (cleanup); 1763 return; 1764 } 1765 1766 error (_("-list-features should be passed no arguments")); 1767 } 1768 1769 void 1770 mi_cmd_list_target_features (char *command, char **argv, int argc) 1771 { 1772 if (argc == 0) 1773 { 1774 struct cleanup *cleanup = NULL; 1775 struct ui_out *uiout = current_uiout; 1776 1777 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features"); 1778 if (target_can_async_p ()) 1779 ui_out_field_string (uiout, NULL, "async"); 1780 if (target_can_execute_reverse) 1781 ui_out_field_string (uiout, NULL, "reverse"); 1782 1783 do_cleanups (cleanup); 1784 return; 1785 } 1786 1787 error (_("-list-target-features should be passed no arguments")); 1788 } 1789 1790 void 1791 mi_cmd_add_inferior (char *command, char **argv, int argc) 1792 { 1793 struct inferior *inf; 1794 1795 if (argc != 0) 1796 error (_("-add-inferior should be passed no arguments")); 1797 1798 inf = add_inferior_with_spaces (); 1799 1800 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num); 1801 } 1802 1803 /* Callback used to find the first inferior other than the current 1804 one. */ 1805 1806 static int 1807 get_other_inferior (struct inferior *inf, void *arg) 1808 { 1809 if (inf == current_inferior ()) 1810 return 0; 1811 1812 return 1; 1813 } 1814 1815 void 1816 mi_cmd_remove_inferior (char *command, char **argv, int argc) 1817 { 1818 int id; 1819 struct inferior *inf; 1820 1821 if (argc != 1) 1822 error (_("-remove-inferior should be passed a single argument")); 1823 1824 if (sscanf (argv[0], "i%d", &id) != 1) 1825 error (_("the thread group id is syntactically invalid")); 1826 1827 inf = find_inferior_id (id); 1828 if (!inf) 1829 error (_("the specified thread group does not exist")); 1830 1831 if (inf->pid != 0) 1832 error (_("cannot remove an active inferior")); 1833 1834 if (inf == current_inferior ()) 1835 { 1836 struct thread_info *tp = 0; 1837 struct inferior *new_inferior 1838 = iterate_over_inferiors (get_other_inferior, NULL); 1839 1840 if (new_inferior == NULL) 1841 error (_("Cannot remove last inferior")); 1842 1843 set_current_inferior (new_inferior); 1844 if (new_inferior->pid != 0) 1845 tp = any_thread_of_process (new_inferior->pid); 1846 switch_to_thread (tp ? tp->ptid : null_ptid); 1847 set_current_program_space (new_inferior->pspace); 1848 } 1849 1850 delete_inferior_1 (inf, 1 /* silent */); 1851 } 1852 1853 1854 1855 /* Execute a command within a safe environment. 1856 Return <0 for error; >=0 for ok. 1857 1858 args->action will tell mi_execute_command what action 1859 to perfrom after the given command has executed (display/suppress 1860 prompt, display error). */ 1861 1862 static void 1863 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) 1864 { 1865 struct cleanup *cleanup; 1866 1867 if (do_timings) 1868 current_command_ts = context->cmd_start; 1869 1870 current_token = xstrdup (context->token); 1871 cleanup = make_cleanup (free_current_contents, ¤t_token); 1872 1873 running_result_record_printed = 0; 1874 mi_proceeded = 0; 1875 switch (context->op) 1876 { 1877 case MI_COMMAND: 1878 /* A MI command was read from the input stream. */ 1879 if (mi_debug_p) 1880 /* FIXME: gdb_???? */ 1881 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n", 1882 context->token, context->command, context->args); 1883 1884 mi_cmd_execute (context); 1885 1886 /* Print the result if there were no errors. 1887 1888 Remember that on the way out of executing a command, you have 1889 to directly use the mi_interp's uiout, since the command 1890 could have reset the interpreter, in which case the current 1891 uiout will most likely crash in the mi_out_* routines. */ 1892 if (!running_result_record_printed) 1893 { 1894 fputs_unfiltered (context->token, raw_stdout); 1895 /* There's no particularly good reason why target-connect results 1896 in not ^done. Should kill ^connected for MI3. */ 1897 fputs_unfiltered (strcmp (context->command, "target-select") == 0 1898 ? "^connected" : "^done", raw_stdout); 1899 mi_out_put (uiout, raw_stdout); 1900 mi_out_rewind (uiout); 1901 mi_print_timing_maybe (); 1902 fputs_unfiltered ("\n", raw_stdout); 1903 } 1904 else 1905 /* The command does not want anything to be printed. In that 1906 case, the command probably should not have written anything 1907 to uiout, but in case it has written something, discard it. */ 1908 mi_out_rewind (uiout); 1909 break; 1910 1911 case CLI_COMMAND: 1912 { 1913 char *argv[2]; 1914 1915 /* A CLI command was read from the input stream. */ 1916 /* This "feature" will be removed as soon as we have a 1917 complete set of mi commands. */ 1918 /* Echo the command on the console. */ 1919 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command); 1920 /* Call the "console" interpreter. */ 1921 argv[0] = "console"; 1922 argv[1] = context->command; 1923 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2); 1924 1925 /* If we changed interpreters, DON'T print out anything. */ 1926 if (current_interp_named_p (INTERP_MI) 1927 || current_interp_named_p (INTERP_MI1) 1928 || current_interp_named_p (INTERP_MI2) 1929 || current_interp_named_p (INTERP_MI3)) 1930 { 1931 if (!running_result_record_printed) 1932 { 1933 fputs_unfiltered (context->token, raw_stdout); 1934 fputs_unfiltered ("^done", raw_stdout); 1935 mi_out_put (uiout, raw_stdout); 1936 mi_out_rewind (uiout); 1937 mi_print_timing_maybe (); 1938 fputs_unfiltered ("\n", raw_stdout); 1939 } 1940 else 1941 mi_out_rewind (uiout); 1942 } 1943 break; 1944 } 1945 } 1946 1947 do_cleanups (cleanup); 1948 } 1949 1950 /* Print a gdb exception to the MI output stream. */ 1951 1952 static void 1953 mi_print_exception (const char *token, struct gdb_exception exception) 1954 { 1955 fputs_unfiltered (token, raw_stdout); 1956 fputs_unfiltered ("^error,msg=\"", raw_stdout); 1957 if (exception.message == NULL) 1958 fputs_unfiltered ("unknown error", raw_stdout); 1959 else 1960 fputstr_unfiltered (exception.message, '"', raw_stdout); 1961 fputs_unfiltered ("\"\n", raw_stdout); 1962 } 1963 1964 void 1965 mi_execute_command (const char *cmd, int from_tty) 1966 { 1967 char *token; 1968 struct mi_parse *command = NULL; 1969 volatile struct gdb_exception exception; 1970 1971 /* This is to handle EOF (^D). We just quit gdb. */ 1972 /* FIXME: we should call some API function here. */ 1973 if (cmd == 0) 1974 quit_force (NULL, from_tty); 1975 1976 target_log_command (cmd); 1977 1978 TRY_CATCH (exception, RETURN_MASK_ALL) 1979 { 1980 command = mi_parse (cmd, &token); 1981 } 1982 if (exception.reason < 0) 1983 { 1984 mi_print_exception (token, exception); 1985 xfree (token); 1986 } 1987 else 1988 { 1989 volatile struct gdb_exception result; 1990 ptid_t previous_ptid = inferior_ptid; 1991 1992 command->token = token; 1993 1994 if (do_timings) 1995 { 1996 command->cmd_start = (struct mi_timestamp *) 1997 xmalloc (sizeof (struct mi_timestamp)); 1998 timestamp (command->cmd_start); 1999 } 2000 2001 TRY_CATCH (result, RETURN_MASK_ALL) 2002 { 2003 captured_mi_execute_command (current_uiout, command); 2004 } 2005 if (result.reason < 0) 2006 { 2007 /* The command execution failed and error() was called 2008 somewhere. */ 2009 mi_print_exception (command->token, result); 2010 mi_out_rewind (current_uiout); 2011 } 2012 2013 bpstat_do_actions (); 2014 2015 if (/* The notifications are only output when the top-level 2016 interpreter (specified on the command line) is MI. */ 2017 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())) 2018 /* Don't try report anything if there are no threads -- 2019 the program is dead. */ 2020 && thread_count () != 0 2021 /* -thread-select explicitly changes thread. If frontend uses that 2022 internally, we don't want to emit =thread-selected, since 2023 =thread-selected is supposed to indicate user's intentions. */ 2024 && strcmp (command->command, "thread-select") != 0) 2025 { 2026 struct mi_interp *mi = top_level_interpreter_data (); 2027 int report_change = 0; 2028 2029 if (command->thread == -1) 2030 { 2031 report_change = (!ptid_equal (previous_ptid, null_ptid) 2032 && !ptid_equal (inferior_ptid, previous_ptid) 2033 && !ptid_equal (inferior_ptid, null_ptid)); 2034 } 2035 else if (!ptid_equal (inferior_ptid, null_ptid)) 2036 { 2037 struct thread_info *ti = inferior_thread (); 2038 2039 report_change = (ti->num != command->thread); 2040 } 2041 2042 if (report_change) 2043 { 2044 struct thread_info *ti = inferior_thread (); 2045 2046 target_terminal_ours (); 2047 fprintf_unfiltered (mi->event_channel, 2048 "thread-selected,id=\"%d\"", 2049 ti->num); 2050 gdb_flush (mi->event_channel); 2051 } 2052 } 2053 2054 mi_parse_free (command); 2055 } 2056 } 2057 2058 static void 2059 mi_cmd_execute (struct mi_parse *parse) 2060 { 2061 struct cleanup *cleanup; 2062 2063 cleanup = prepare_execute_command (); 2064 2065 if (parse->all && parse->thread_group != -1) 2066 error (_("Cannot specify --thread-group together with --all")); 2067 2068 if (parse->all && parse->thread != -1) 2069 error (_("Cannot specify --thread together with --all")); 2070 2071 if (parse->thread_group != -1 && parse->thread != -1) 2072 error (_("Cannot specify --thread together with --thread-group")); 2073 2074 if (parse->frame != -1 && parse->thread == -1) 2075 error (_("Cannot specify --frame without --thread")); 2076 2077 if (parse->thread_group != -1) 2078 { 2079 struct inferior *inf = find_inferior_id (parse->thread_group); 2080 struct thread_info *tp = 0; 2081 2082 if (!inf) 2083 error (_("Invalid thread group for the --thread-group option")); 2084 2085 set_current_inferior (inf); 2086 /* This behaviour means that if --thread-group option identifies 2087 an inferior with multiple threads, then a random one will be 2088 picked. This is not a problem -- frontend should always 2089 provide --thread if it wishes to operate on a specific 2090 thread. */ 2091 if (inf->pid != 0) 2092 tp = any_live_thread_of_process (inf->pid); 2093 switch_to_thread (tp ? tp->ptid : null_ptid); 2094 set_current_program_space (inf->pspace); 2095 } 2096 2097 if (parse->thread != -1) 2098 { 2099 struct thread_info *tp = find_thread_id (parse->thread); 2100 2101 if (!tp) 2102 error (_("Invalid thread id: %d"), parse->thread); 2103 2104 if (is_exited (tp->ptid)) 2105 error (_("Thread id: %d has terminated"), parse->thread); 2106 2107 switch_to_thread (tp->ptid); 2108 } 2109 2110 if (parse->frame != -1) 2111 { 2112 struct frame_info *fid; 2113 int frame = parse->frame; 2114 2115 fid = find_relative_frame (get_current_frame (), &frame); 2116 if (frame == 0) 2117 /* find_relative_frame was successful */ 2118 select_frame (fid); 2119 else 2120 error (_("Invalid frame id: %d"), frame); 2121 } 2122 2123 current_context = parse; 2124 2125 if (parse->cmd->suppress_notification != NULL) 2126 { 2127 make_cleanup_restore_integer (parse->cmd->suppress_notification); 2128 *parse->cmd->suppress_notification = 1; 2129 } 2130 2131 if (parse->cmd->argv_func != NULL) 2132 { 2133 parse->cmd->argv_func (parse->command, parse->argv, parse->argc); 2134 } 2135 else if (parse->cmd->cli.cmd != 0) 2136 { 2137 /* FIXME: DELETE THIS. */ 2138 /* The operation is still implemented by a cli command. */ 2139 /* Must be a synchronous one. */ 2140 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p, 2141 parse->args); 2142 } 2143 else 2144 { 2145 /* FIXME: DELETE THIS. */ 2146 struct ui_file *stb; 2147 2148 stb = mem_fileopen (); 2149 2150 fputs_unfiltered ("Undefined mi command: ", stb); 2151 fputstr_unfiltered (parse->command, '"', stb); 2152 fputs_unfiltered (" (missing implementation)", stb); 2153 2154 make_cleanup_ui_file_delete (stb); 2155 error_stream (stb); 2156 } 2157 do_cleanups (cleanup); 2158 } 2159 2160 /* FIXME: This is just a hack so we can get some extra commands going. 2161 We don't want to channel things through the CLI, but call libgdb directly. 2162 Use only for synchronous commands. */ 2163 2164 void 2165 mi_execute_cli_command (const char *cmd, int args_p, const char *args) 2166 { 2167 if (cmd != 0) 2168 { 2169 struct cleanup *old_cleanups; 2170 char *run; 2171 2172 if (args_p) 2173 run = xstrprintf ("%s %s", cmd, args); 2174 else 2175 run = xstrdup (cmd); 2176 if (mi_debug_p) 2177 /* FIXME: gdb_???? */ 2178 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n", 2179 cmd, run); 2180 old_cleanups = make_cleanup (xfree, run); 2181 execute_command (run, 0 /* from_tty */ ); 2182 do_cleanups (old_cleanups); 2183 return; 2184 } 2185 } 2186 2187 void 2188 mi_execute_async_cli_command (char *cli_command, char **argv, int argc) 2189 { 2190 struct cleanup *old_cleanups; 2191 char *run; 2192 2193 if (target_can_async_p ()) 2194 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : ""); 2195 else 2196 run = xstrprintf ("%s %s", cli_command, argc ? *argv : ""); 2197 old_cleanups = make_cleanup (xfree, run); 2198 2199 execute_command (run, 0 /* from_tty */ ); 2200 2201 /* Do this before doing any printing. It would appear that some 2202 print code leaves garbage around in the buffer. */ 2203 do_cleanups (old_cleanups); 2204 } 2205 2206 void 2207 mi_load_progress (const char *section_name, 2208 unsigned long sent_so_far, 2209 unsigned long total_section, 2210 unsigned long total_sent, 2211 unsigned long grand_total) 2212 { 2213 struct timeval time_now, delta, update_threshold; 2214 static struct timeval last_update; 2215 static char *previous_sect_name = NULL; 2216 int new_section; 2217 struct ui_out *saved_uiout; 2218 struct ui_out *uiout; 2219 2220 /* This function is called through deprecated_show_load_progress 2221 which means uiout may not be correct. Fix it for the duration 2222 of this function. */ 2223 saved_uiout = current_uiout; 2224 2225 if (current_interp_named_p (INTERP_MI) 2226 || current_interp_named_p (INTERP_MI2)) 2227 current_uiout = mi_out_new (2); 2228 else if (current_interp_named_p (INTERP_MI1)) 2229 current_uiout = mi_out_new (1); 2230 else if (current_interp_named_p (INTERP_MI3)) 2231 current_uiout = mi_out_new (3); 2232 else 2233 return; 2234 2235 uiout = current_uiout; 2236 2237 update_threshold.tv_sec = 0; 2238 update_threshold.tv_usec = 500000; 2239 gettimeofday (&time_now, NULL); 2240 2241 delta.tv_usec = time_now.tv_usec - last_update.tv_usec; 2242 delta.tv_sec = time_now.tv_sec - last_update.tv_sec; 2243 2244 if (delta.tv_usec < 0) 2245 { 2246 delta.tv_sec -= 1; 2247 delta.tv_usec += 1000000L; 2248 } 2249 2250 new_section = (previous_sect_name ? 2251 strcmp (previous_sect_name, section_name) : 1); 2252 if (new_section) 2253 { 2254 struct cleanup *cleanup_tuple; 2255 2256 xfree (previous_sect_name); 2257 previous_sect_name = xstrdup (section_name); 2258 2259 if (current_token) 2260 fputs_unfiltered (current_token, raw_stdout); 2261 fputs_unfiltered ("+download", raw_stdout); 2262 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 2263 ui_out_field_string (uiout, "section", section_name); 2264 ui_out_field_int (uiout, "section-size", total_section); 2265 ui_out_field_int (uiout, "total-size", grand_total); 2266 do_cleanups (cleanup_tuple); 2267 mi_out_put (uiout, raw_stdout); 2268 fputs_unfiltered ("\n", raw_stdout); 2269 gdb_flush (raw_stdout); 2270 } 2271 2272 if (delta.tv_sec >= update_threshold.tv_sec && 2273 delta.tv_usec >= update_threshold.tv_usec) 2274 { 2275 struct cleanup *cleanup_tuple; 2276 2277 last_update.tv_sec = time_now.tv_sec; 2278 last_update.tv_usec = time_now.tv_usec; 2279 if (current_token) 2280 fputs_unfiltered (current_token, raw_stdout); 2281 fputs_unfiltered ("+download", raw_stdout); 2282 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 2283 ui_out_field_string (uiout, "section", section_name); 2284 ui_out_field_int (uiout, "section-sent", sent_so_far); 2285 ui_out_field_int (uiout, "section-size", total_section); 2286 ui_out_field_int (uiout, "total-sent", total_sent); 2287 ui_out_field_int (uiout, "total-size", grand_total); 2288 do_cleanups (cleanup_tuple); 2289 mi_out_put (uiout, raw_stdout); 2290 fputs_unfiltered ("\n", raw_stdout); 2291 gdb_flush (raw_stdout); 2292 } 2293 2294 xfree (uiout); 2295 current_uiout = saved_uiout; 2296 } 2297 2298 static void 2299 timestamp (struct mi_timestamp *tv) 2300 { 2301 gettimeofday (&tv->wallclock, NULL); 2302 #ifdef HAVE_GETRUSAGE 2303 getrusage (RUSAGE_SELF, &rusage); 2304 tv->utime.tv_sec = rusage.ru_utime.tv_sec; 2305 tv->utime.tv_usec = rusage.ru_utime.tv_usec; 2306 tv->stime.tv_sec = rusage.ru_stime.tv_sec; 2307 tv->stime.tv_usec = rusage.ru_stime.tv_usec; 2308 #else 2309 { 2310 long usec = get_run_time (); 2311 2312 tv->utime.tv_sec = usec/1000000L; 2313 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec; 2314 tv->stime.tv_sec = 0; 2315 tv->stime.tv_usec = 0; 2316 } 2317 #endif 2318 } 2319 2320 static void 2321 print_diff_now (struct mi_timestamp *start) 2322 { 2323 struct mi_timestamp now; 2324 2325 timestamp (&now); 2326 print_diff (start, &now); 2327 } 2328 2329 void 2330 mi_print_timing_maybe (void) 2331 { 2332 /* If the command is -enable-timing then do_timings may be true 2333 whilst current_command_ts is not initialized. */ 2334 if (do_timings && current_command_ts) 2335 print_diff_now (current_command_ts); 2336 } 2337 2338 static long 2339 timeval_diff (struct timeval start, struct timeval end) 2340 { 2341 return ((end.tv_sec - start.tv_sec) * 1000000L) 2342 + (end.tv_usec - start.tv_usec); 2343 } 2344 2345 static void 2346 print_diff (struct mi_timestamp *start, struct mi_timestamp *end) 2347 { 2348 fprintf_unfiltered 2349 (raw_stdout, 2350 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}", 2351 timeval_diff (start->wallclock, end->wallclock) / 1000000.0, 2352 timeval_diff (start->utime, end->utime) / 1000000.0, 2353 timeval_diff (start->stime, end->stime) / 1000000.0); 2354 } 2355 2356 void 2357 mi_cmd_trace_define_variable (char *command, char **argv, int argc) 2358 { 2359 struct expression *expr; 2360 LONGEST initval = 0; 2361 struct trace_state_variable *tsv; 2362 char *name = 0; 2363 2364 if (argc != 1 && argc != 2) 2365 error (_("Usage: -trace-define-variable VARIABLE [VALUE]")); 2366 2367 name = argv[0]; 2368 if (*name++ != '$') 2369 error (_("Name of trace variable should start with '$'")); 2370 2371 validate_trace_state_variable_name (name); 2372 2373 tsv = find_trace_state_variable (name); 2374 if (!tsv) 2375 tsv = create_trace_state_variable (name); 2376 2377 if (argc == 2) 2378 initval = value_as_long (parse_and_eval (argv[1])); 2379 2380 tsv->initial_value = initval; 2381 } 2382 2383 void 2384 mi_cmd_trace_list_variables (char *command, char **argv, int argc) 2385 { 2386 if (argc != 0) 2387 error (_("-trace-list-variables: no arguments allowed")); 2388 2389 tvariables_info_1 (); 2390 } 2391 2392 void 2393 mi_cmd_trace_find (char *command, char **argv, int argc) 2394 { 2395 char *mode; 2396 2397 if (argc == 0) 2398 error (_("trace selection mode is required")); 2399 2400 mode = argv[0]; 2401 2402 if (strcmp (mode, "none") == 0) 2403 { 2404 tfind_1 (tfind_number, -1, 0, 0, 0); 2405 return; 2406 } 2407 2408 if (current_trace_status ()->running) 2409 error (_("May not look at trace frames while trace is running.")); 2410 2411 if (strcmp (mode, "frame-number") == 0) 2412 { 2413 if (argc != 2) 2414 error (_("frame number is required")); 2415 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0); 2416 } 2417 else if (strcmp (mode, "tracepoint-number") == 0) 2418 { 2419 if (argc != 2) 2420 error (_("tracepoint number is required")); 2421 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0); 2422 } 2423 else if (strcmp (mode, "pc") == 0) 2424 { 2425 if (argc != 2) 2426 error (_("PC is required")); 2427 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0); 2428 } 2429 else if (strcmp (mode, "pc-inside-range") == 0) 2430 { 2431 if (argc != 3) 2432 error (_("Start and end PC are required")); 2433 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]), 2434 parse_and_eval_address (argv[2]), 0); 2435 } 2436 else if (strcmp (mode, "pc-outside-range") == 0) 2437 { 2438 if (argc != 3) 2439 error (_("Start and end PC are required")); 2440 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]), 2441 parse_and_eval_address (argv[2]), 0); 2442 } 2443 else if (strcmp (mode, "line") == 0) 2444 { 2445 struct symtabs_and_lines sals; 2446 struct symtab_and_line sal; 2447 static CORE_ADDR start_pc, end_pc; 2448 struct cleanup *back_to; 2449 2450 if (argc != 2) 2451 error (_("Line is required")); 2452 2453 sals = decode_line_with_current_source (argv[1], 2454 DECODE_LINE_FUNFIRSTLINE); 2455 back_to = make_cleanup (xfree, sals.sals); 2456 2457 sal = sals.sals[0]; 2458 2459 if (sal.symtab == 0) 2460 error (_("Could not find the specified line")); 2461 2462 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc)) 2463 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0); 2464 else 2465 error (_("Could not find the specified line")); 2466 2467 do_cleanups (back_to); 2468 } 2469 else 2470 error (_("Invalid mode '%s'"), mode); 2471 2472 if (has_stack_frames () || get_traceframe_number () >= 0) 2473 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 2474 } 2475 2476 void 2477 mi_cmd_trace_save (char *command, char **argv, int argc) 2478 { 2479 int target_saves = 0; 2480 char *filename; 2481 2482 if (argc != 1 && argc != 2) 2483 error (_("Usage: -trace-save [-r] filename")); 2484 2485 if (argc == 2) 2486 { 2487 filename = argv[1]; 2488 if (strcmp (argv[0], "-r") == 0) 2489 target_saves = 1; 2490 else 2491 error (_("Invalid option: %s"), argv[0]); 2492 } 2493 else 2494 { 2495 filename = argv[0]; 2496 } 2497 2498 trace_save (filename, target_saves); 2499 } 2500 2501 void 2502 mi_cmd_trace_start (char *command, char **argv, int argc) 2503 { 2504 start_tracing (NULL); 2505 } 2506 2507 void 2508 mi_cmd_trace_status (char *command, char **argv, int argc) 2509 { 2510 trace_status_mi (0); 2511 } 2512 2513 void 2514 mi_cmd_trace_stop (char *command, char **argv, int argc) 2515 { 2516 stop_tracing (NULL); 2517 trace_status_mi (1); 2518 } 2519 2520 /* Implement the "-ada-task-info" command. */ 2521 2522 void 2523 mi_cmd_ada_task_info (char *command, char **argv, int argc) 2524 { 2525 if (argc != 0 && argc != 1) 2526 error (_("Invalid MI command")); 2527 2528 print_ada_task_info (current_uiout, argv[0], current_inferior ()); 2529 } 2530