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