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